n8n-workflow 2.42.2 → 2.43.0

package/dist/esm/expressions/native-evaluation/evaluator.js

@@ -0,0 +1,366 @@
+import { ExpressionExtensionError } from '../../errors/expression-extension.error';
+import { ExpressionError } from '../../errors/expression.error';
+import { ARRAY_METHODS, MAX_DEPTH, MAX_RESULT_LENGTH, NUMBER_METHODS, STRING_METHODS, hasOwn, isArray, isObj, toNum, toStr, } from './grammar';
+// ── Evaluation: total over the grammar. ────────────────────────────────────
+//
+// evalNode reads only fields parseSimple constructed, because those are the
+// only fields that exist. The switch has no default branch: adding a kind to
+// the grammar stops compilation until it is handled here.
+/**
+ * Thrown when a runtime value falls outside what parsing proved statically
+ * (a whitelisted string method on a non-string receiver, an operator on an
+ * object operand, a result above MAX_RESULT_LENGTH). The whole evaluation is
+ * abandoned and the caller re-runs the expression through the regular engine
+ * pipeline. Anything evaluated before the bail runs again in the engine: a
+ * nested `$parameter` expression, or a getter on a data object. Expressions
+ * are pure and workflow data is JSON, so the only cost is the repeated work.
+ */
+export class EngineFallbackError extends Error {
+}
+/**
+ * Thrown by an optional member/call on a nullish receiver and caught by the
+ * enclosing chain node, which yields undefined for the whole chain. One
+ * shared instance: a missing optional hop is ordinary data, not an error.
+ */
+class ChainShortCircuit extends Error {
+}
+const chainShortCircuit = new ChainShortCircuit();
+/**
+ * Property lookup on a non-nullish primitive is well-defined and side-effect
+ * free, so primitives are indexable here even though the predicate's type
+ * only names objects.
+ */
+const isIndexable = (value) => value !== null && value !== undefined;
+/**
+ * Operators only ever see primitives. An object operand would coerce through
+ * its valueOf/toString on the host, where the engine sees a structured-clone
+ * copy; a reference comparison would differ from the engine's copy semantics.
+ */
+const isPrimitive = (value) => value === null || (typeof value !== 'object' && typeof value !== 'function');
+export function bounded(value) {
+    const isSizeable = typeof value === 'string' || isArray(value);
+    if (isSizeable && value.length > MAX_RESULT_LENGTH) {
+        throw new EngineFallbackError();
+    }
+    return value;
+}
+// Operand casts are intentional: the interpreter must reproduce JS coercion
+// semantics exactly (parity with the engines), not re-implement them.
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const binaryOps = Object.freeze({
+    '===': (l, r) => l === r,
+    '!==': (l, r) => l !== r,
+    // eslint-disable-next-line eqeqeq
+    '==': (l, r) => l == r,
+    // eslint-disable-next-line eqeqeq
+    '!=': (l, r) => l != r,
+    '<': (l, r) => l < r,
+    '<=': (l, r) => l <= r,
+    '>': (l, r) => l > r,
+    '>=': (l, r) => l >= r,
+    '+': (l, r) => bounded(l + r),
+    '-': (l, r) => l - r,
+    '*': (l, r) => l * r,
+    '/': (l, r) => l / r,
+    '%': (l, r) => l % r,
+});
+/* eslint-enable @typescript-eslint/no-explicit-any */
+function evalMember(node, data) {
+    const object = evalNode(node.object, data);
+    if (node.optional && (object === null || object === undefined)) {
+        throw chainShortCircuit;
+    }
+    if (!isIndexable(object)) {
+        throw new TypeError(`Cannot read properties of ${toStr(object)} (reading '${node.key}')`);
+    }
+    // Below the roots (get-trap proxies, where Object.hasOwn misreports every
+    // key) the data is plain JSON, so an inherited property is a host prototype
+    // the isolates never see. The engine decides what it yields.
+    const inherited = node.object.kind !== 'root' &&
+        typeof object === 'object' &&
+        node.key in object &&
+        !hasOwn(object, node.key);
+    if (inherited) {
+        throw new EngineFallbackError();
+    }
+    const value = object[node.key];
+    // Neither crosses an engine boundary the same way twice (the vm bridge
+    // drops a nested function but fails on an inherited one; legacy throws),
+    // so the configured engine decides rather than this module guessing.
+    if (typeof value === 'function' || typeof value === 'symbol') {
+        throw new EngineFallbackError();
+    }
+    return value;
+}
+/**
+ * Parsing only proves the method name; the receiver's type is data. A
+ * receiver whose type has no allowlist entry for the method could be
+ * intercepted by extensions, so it hands the whole expression to the engine.
+ */
+function methodFor(receiver, name) {
+    let method;
+    if (typeof receiver === 'string') {
+        method = STRING_METHODS.get(name);
+    }
+    else if (typeof receiver === 'number') {
+        method = NUMBER_METHODS.get(name);
+    }
+    else if (isArray(receiver)) {
+        method = ARRAY_METHODS.get(name);
+    }
+    if (method === undefined)
+        throw new EngineFallbackError();
+    return method;
+}
+/**
+ * Arguments are primitives, plus arrays for concat. An object argument would
+ * compare by live reference where the isolate compares copies (includes/
+ * indexOf) or coerce on the host where the isolate sees a copy.
+ */
+function isAllowedArgument(method, arg) {
+    if (isPrimitive(arg))
+        return true;
+    return method === 'concat' && isArray(arg);
+}
+/**
+ * The engine runs under a timeout; a synchronous native call cannot be
+ * interrupted, so the input size is the budget. A receiver above the result
+ * cap goes to the engine before any work is done, and the amplifying methods
+ * (which can allocate far beyond MAX_RESULT_LENGTH before bounded() sees the
+ * result) bail on an upper bound of their output.
+ */
+function assertPreflightSize(receiver, method, args) {
+    let upperBound = typeof receiver === 'number' ? 0 : receiver.length;
+    if (method === 'concat') {
+        for (const arg of args) {
+            upperBound += isArray(arg) ? arg.length : 1;
+        }
+    }
+    else if (method === 'flat' && isArray(receiver)) {
+        const depth = args.length === 0 ? 1 : toNum(args[0]);
+        upperBound = flatSize(receiver, depth);
+    }
+    else if ((method === 'replace' || method === 'replaceAll') && typeof receiver === 'string') {
+        // A missing replacement inserts the string "undefined".
+        const replacement = args.length < 2 ? 'undefined' : toStr(args[1]);
+        // Three replacement tokens expand: `$&`, `$\`` and `$'` insert match
+        // context, so the output is not bounded by the replacement's length.
+        // `$$` is an escaped literal `$`; strip those pairs first so that `$$&`
+        // (a literal "$&") stays native while `$$$&` (a literal "$" then `$&`)
+        // bails. With a string pattern every other `$` is literal.
+        if (/\$[&`']/.test(replacement.replaceAll('$$', '')))
+            throw new EngineFallbackError();
+        upperBound =
+            method === 'replace'
+                ? receiver.length + replacement.length
+                : (receiver.length + 1) * (replacement.length + 1);
+    }
+    else if (method === 'join' && isArray(receiver)) {
+        // Only an undefined separator means ","; null joins with "null".
+        const separator = args[0] === undefined ? ',' : toStr(args[0]);
+        upperBound = separator.length * Math.max(receiver.length - 1, 0);
+        for (const element of receiver) {
+            upperBound += toStr(element ?? '').length;
+        }
+    }
+    if (upperBound > MAX_RESULT_LENGTH) {
+        throw new EngineFallbackError();
+    }
+}
+/**
+ * Element count of `array.flat(depth)`, stopping early once past the cap
+ * (a nested structure can flatten to far more elements than the outer
+ * array holds).
+ */
+function flatSize(array, depth) {
+    let size = 0;
+    for (const element of array) {
+        size += depth >= 1 && isArray(element) ? flatSize(element, depth - 1) : 1;
+        if (size > MAX_RESULT_LENGTH)
+            break;
+    }
+    return size;
+}
+/**
+ * Array methods that call toString on their elements: join() on every
+ * element, toSorted()'s default comparator on both operands per comparison.
+ * On nested arrays that work is proportional to the nested size, which no
+ * element count bounds, so these run natively over primitive elements only.
+ */
+const STRINGIFIES_ELEMENTS = new Set(['join', 'toSorted']);
+/**
+ * Hands off to the engine unless every element is a primitive. O(n) over a
+ * receiver the size cap already limits, and runs before anything is
+ * stringified.
+ */
+function assertPrimitiveElements(receiver) {
+    // The receiver cap applies before the scan, so the scan never walks more
+    // than the cap either.
+    if (receiver.length > MAX_RESULT_LENGTH)
+        throw new EngineFallbackError();
+    for (const element of receiver) {
+        if (!isPrimitive(element))
+            throw new EngineFallbackError();
+    }
+}
+/**
+ * Content size of a JSON value: string lengths plus one per element and
+ * key, stopping early past the budget. Deeper than the grammar's own depth
+ * cap hands off: the engine owns data that deep.
+ */
+function contentWeight(value, budget, depth = 0) {
+    if (depth > MAX_DEPTH)
+        throw new EngineFallbackError();
+    if (typeof value === 'string')
+        return value.length;
+    if (!isObj(value))
+        return 1;
+    let weight = 1;
+    if (isArray(value)) {
+        for (const element of value) {
+            weight += contentWeight(element, budget - weight, depth + 1);
+            if (weight > budget)
+                break;
+        }
+        return weight;
+    }
+    // Walk keys without materialising an entries array: an object with many
+    // keys would otherwise be copied before the budget is checked.
+    for (const key in value) {
+        if (!hasOwn(value, key))
+            continue;
+        weight += key.length + contentWeight(value[key], budget - weight, depth + 1);
+        if (weight > budget)
+            break;
+    }
+    return weight;
+}
+/**
+ * concat() is the one method that can hold more content than the payload
+ * delivered: N arguments that reference one large string become N copies
+ * when the result is cloned (copyResult) and N operands for every method
+ * downstream (join, toSorted, includes). Element count does not see that,
+ * so concat is bounded by the content size of receiver plus arguments.
+ */
+function assertConcatWeight(receiver, args) {
+    let weight = contentWeight(receiver, MAX_RESULT_LENGTH);
+    for (const arg of args) {
+        if (weight > MAX_RESULT_LENGTH)
+            break;
+        weight += contentWeight(arg, MAX_RESULT_LENGTH - weight);
+    }
+    if (weight > MAX_RESULT_LENGTH)
+        throw new EngineFallbackError();
+}
+function evalCall(node, data) {
+    const receiver = evalNode(node.receiver, data);
+    const receiverMissing = receiver === null || receiver === undefined;
+    if (node.optional && receiverMissing) {
+        throw chainShortCircuit;
+    }
+    if (receiverMissing) {
+        throw new TypeError(`Cannot read properties of ${toStr(receiver)} (reading '${node.method}')`);
+    }
+    // An own property shadowing the method (an engine-resolved $parameter value
+    // can carry one) would take precedence in the engines.
+    if (hasOwn(receiver, node.method)) {
+        throw new EngineFallbackError();
+    }
+    const method = methodFor(receiver, node.method);
+    const args = node.args.map((argument) => evalNode(argument, data));
+    if (!args.every((arg) => isAllowedArgument(node.method, arg))) {
+        throw new EngineFallbackError();
+    }
+    if (isArray(receiver)) {
+        if (STRINGIFIES_ELEMENTS.has(node.method))
+            assertPrimitiveElements(receiver);
+        if (node.method === 'concat')
+            assertConcatWeight(receiver, args);
+    }
+    assertPreflightSize(receiver, node.method, args);
+    return bounded(method.apply(receiver, args));
+}
+function evalChain(node, data) {
+    try {
+        return evalNode(node.expression, data);
+    }
+    catch (error) {
+        if (error === chainShortCircuit)
+            return undefined;
+        throw error;
+    }
+}
+function evalUnary(node, data) {
+    const argument = evalNode(node.argument, data);
+    if (node.op === '!') {
+        return !argument;
+    }
+    if (!isPrimitive(argument)) {
+        throw new EngineFallbackError();
+    }
+    return node.op === '-' ? -toNum(argument) : toNum(argument);
+}
+function evalBinary(node, data) {
+    const left = evalNode(node.left, data);
+    const right = evalNode(node.right, data);
+    if (!isPrimitive(left) || !isPrimitive(right)) {
+        throw new EngineFallbackError();
+    }
+    return binaryOps[node.op](left, right);
+}
+function evalLogical(node, data) {
+    const left = evalNode(node.left, data);
+    switch (node.op) {
+        case '&&':
+            return left ? evalNode(node.right, data) : left;
+        case '||':
+            return left ? left : evalNode(node.right, data);
+        case '??':
+            return left ?? evalNode(node.right, data);
+    }
+}
+function evalNode(node, data) {
+    switch (node.kind) {
+        case 'literal':
+            return node.value;
+        case 'root':
+            return node.name === '$json' ? data.$json : data.$parameter;
+        case 'undefined':
+            return undefined;
+        case 'member':
+            return evalMember(node, data);
+        case 'chain':
+            return evalChain(node, data);
+        case 'unary':
+            return evalUnary(node, data);
+        case 'binary':
+            return evalBinary(node, data);
+        case 'logical':
+            return evalLogical(node, data);
+        case 'conditional':
+            return evalNode(node.test, data)
+                ? evalNode(node.consequent, data)
+                : evalNode(node.alternate, data);
+        case 'call':
+            return evalCall(node, data);
+    }
+}
+/**
+ * Tournament wraps each code chunk in try/catch and routes errors to the E()
+ * handler, which rethrows ExpressionErrors and swallows everything else (the
+ * chunk then yields undefined). Mirror that exactly.
+ */
+export function evalChunk(node, data) {
+    try {
+        return evalNode(node, data);
+    }
+    catch (error) {
+        const rethrow = error instanceof EngineFallbackError ||
+            error instanceof ExpressionError ||
+            error instanceof ExpressionExtensionError;
+        if (rethrow)
+            throw error;
+        return undefined;
+    }
+}
+//# sourceMappingURL=evaluator.js.map

package/dist/esm/expressions/native-evaluation/evaluator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluator.js","sourceRoot":"","sources":["../../../../src/expressions/native-evaluation/evaluator.ts"],"names":[],"mappings":"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"}

package/dist/esm/expressions/native-evaluation/grammar.d.ts

@@ -0,0 +1,63 @@
+import type { namedTypes } from 'ast-types';
+export declare const BINARY_OPS: readonly ['===', '!==', '==', '!=', '<', '<=', '>', '>=', '+', '-', '*', '/', '%'];
+export declare const UNARY_OPS: readonly ['!', '-', '+'];
+export type BinaryOp = (typeof BINARY_OPS)[number];
+export type LogicalOp = namedTypes.LogicalExpression['operator'];
+export type UnaryOp = (typeof UNARY_OPS)[number];
+export type SimpleNode = {
+    kind: 'literal';
+    value: string | number | boolean | null;
+} | {
+    kind: 'root';
+    name: '$json' | '$parameter';
+} | {
+    kind: 'undefined';
+} | {
+    kind: 'member';
+    object: SimpleNode;
+    key: string | number;
+    optional: boolean;
+} | {
+    kind: 'chain';
+    expression: SimpleNode;
+} | {
+    kind: 'unary';
+    op: UnaryOp;
+    argument: SimpleNode;
+} | {
+    kind: 'binary';
+    op: BinaryOp;
+    left: SimpleNode;
+    right: SimpleNode;
+} | {
+    kind: 'logical';
+    op: LogicalOp;
+    left: SimpleNode;
+    right: SimpleNode;
+} | {
+    kind: 'conditional';
+    test: SimpleNode;
+    consequent: SimpleNode;
+    alternate: SimpleNode;
+} | {
+    kind: 'call';
+    receiver: SimpleNode;
+    method: string;
+    args: SimpleNode[];
+    optional: boolean;
+};
+export declare const isArray: (arg: any) => arg is any[];
+export declare const hasOwn: (o: object, v: PropertyKey) => boolean;
+export declare const toStr: StringConstructor;
+export declare const toNum: NumberConstructor;
+export declare const clone: typeof structuredClone;
+export type NativeMethod = (this: unknown, ...args: unknown[]) => unknown;
+export declare const STRING_METHODS: ReadonlyMap<string, NativeMethod>;
+export declare const NUMBER_METHODS: ReadonlyMap<string, NativeMethod>;
+export declare const ARRAY_METHODS: ReadonlyMap<string, NativeMethod>;
+export declare const CALLABLE_METHODS: Set<string>;
+export declare const MAX_RESULT_LENGTH = 1000000;
+export declare const MAX_DEPTH = 64;
+export declare const isObj: (value: unknown) => value is Record<string, unknown>;
+export declare const isOneOf: <T extends string>(ops: readonly T[], op: unknown) => op is T;
+//# sourceMappingURL=grammar.d.ts.map

package/dist/esm/expressions/native-evaluation/grammar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grammar.d.ts","sourceRoot":"","sources":["../../../../src/expressions/native-evaluation/grammar.ts"],"names":[],"mappings":"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"}

package/dist/esm/expressions/native-evaluation/grammar.js

@@ -0,0 +1,108 @@
+// The closed subset grammar, its operator and method allowlists, and the
+// limits the parser and the evaluator share. See index.ts for the overview.
+export const BINARY_OPS = [
+    '===',
+    '!==',
+    '==',
+    '!=',
+    '<',
+    '<=',
+    '>',
+    '>=',
+    '+',
+    '-',
+    '*',
+    '/',
+    '%',
+];
+export const UNARY_OPS = ['!', '-', '+'];
+// Roots are `$json` and `$parameter` only (the literal comparisons in
+// parseIdentifier). More roots are CAT-4697. `$now`/`$today` are excluded on
+// purpose: they are Luxon DateTimes whose methods would make every useful
+// expression on them a CallExpression anyway.
+//
+// Note on $parameter: the proxy resolves nested `=` parameter values by
+// re-entering resolveSimpleParameterValue - a nested non-simple value simply
+// takes the engine path there (under lazy acquisition, creating the bridge on
+// demand).
+// Intrinsics are captured at import so a later patch to a prototype or a
+// global (a polyfill, a community package) does not change what the native
+// path runs; the isolates never see such a patch either.
+export const { isArray } = Array;
+export const { hasOwn } = Object;
+export const toStr = String;
+export const toNum = Number;
+export const clone = structuredClone;
+const captureMethods = (proto, names) => {
+    const methods = new Map();
+    for (const name of names) {
+        const method = Reflect.get(proto, name);
+        if (typeof method === 'function')
+            methods.set(name, method);
+    }
+    return methods;
+};
+// Native prototype methods callable on a receiver of the matching type.
+// Every name here must stay disjoint from the expression-extension method
+// names (extendSyntax rewrites extension calls into `extend()` dispatch;
+// natives pass through untouched) - pinned by a test in the parity corpus.
+// The receiver's type is only known at runtime: a receiver whose type has no
+// allowlist entry for the method makes the evaluation bail to the engine
+// (EngineFallbackError below). Callback-taking forms (regex/function args,
+// array callbacks) are unrepresentable: those argument nodes decline parsing.
+// Accepting callbacks is CAT-4698.
+export const STRING_METHODS = captureMethods(String.prototype, [
+    'toUpperCase',
+    'toLowerCase',
+    'trim',
+    'trimStart',
+    'trimEnd',
+    'includes',
+    'startsWith',
+    'endsWith',
+    'slice',
+    'indexOf',
+    'charAt',
+    'replace',
+    'replaceAll',
+]);
+export const NUMBER_METHODS = captureMethods(Number.prototype, [
+    'toFixed',
+    'toPrecision',
+    'toString',
+]);
+// Non-mutating methods only: the receiver is the live workflow data (the vm
+// engine evaluates a copy inside the isolate), so an in-place mutator like
+// sort()/reverse()/fill() would corrupt execution data as a side effect. Use
+// the toSorted()/toReversed() immutable variants instead. Iterator-returning
+// methods (entries/values/keys) are also excluded: a live iterator has no
+// equivalent representation across the engine boundary.
+export const ARRAY_METHODS = captureMethods(Array.prototype, [
+    'includes',
+    'indexOf',
+    'lastIndexOf',
+    'join',
+    'slice',
+    'at',
+    'concat',
+    'flat',
+    'toSorted',
+    'toReversed',
+]);
+export const CALLABLE_METHODS = new Set([
+    ...STRING_METHODS.keys(),
+    ...NUMBER_METHODS.keys(),
+    ...ARRAY_METHODS.keys(),
+]);
+// The engine evaluates under a timeout and a memory limit; this interpreter
+// has neither. A string or array result above this length is handed to the
+// engine so those limits apply (nested replaceAll('', ...) or concat chains
+// can otherwise expand without bound on the main thread).
+export const MAX_RESULT_LENGTH = 1_000_000;
+// Nesting depth of the subset grammar. Parsing and evaluation both recurse
+// once per level, so this keeps a pathological expression off the host stack;
+// real expressions are a handful of levels deep.
+export const MAX_DEPTH = 64;
+export const isObj = (value) => typeof value === 'object' && value !== null;
+export const isOneOf = (ops, op) => typeof op === 'string' && ops.includes(op);
+//# sourceMappingURL=grammar.js.map

package/dist/esm/expressions/native-evaluation/grammar.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"grammar.js","sourceRoot":"","sources":["../../../../src/expressions/native-evaluation/grammar.ts"],"names":[],"mappings":"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"}

package/dist/esm/expressions/native-evaluation/index.d.ts

@@ -0,0 +1,17 @@
+import type { IWorkflowDataProxyData } from '../../interfaces';
+export { CALLABLE_METHODS, MAX_RESULT_LENGTH } from './grammar';
+/** Does the expression (leading `=` stripped) fit the native subset? */
+export declare function isNativelyEvaluable(expression: string): boolean;
+/**
+ * Evaluate an expression (with the leading `=` already stripped) in-process.
+ * Returns `{ handled: false }` when the expression is outside the subset or a
+ * runtime value fell outside what parsing proved; the caller must then run
+ * the regular pipeline.
+ */
+export declare function evaluateNatively(expression: string, data: IWorkflowDataProxyData): {
+    handled: true;
+    value: unknown;
+} | {
+    handled: false;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/expressions/native-evaluation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/expressions/native-evaluation/index.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAE/D,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAyGhE,wEAAwE;AACxE,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAE/D;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC/B,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,sBAAsB,GAC1B;IAAE,OAAO,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,GAAG;IAAE,OAAO,EAAE,KAAK,CAAA;CAAE,CAYxD"}