n8n-workflow 0.117.2 → 0.118.0

package/dist/src/WorkflowDataProxy.js

@@ -26,7 +26,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkflowDataProxy = exports.isResourceLocatorValue = void 0;
 const luxon_1 = require("luxon");
 const jmespath = __importStar(require("jmespath"));
-const _1 = require(".");
+const NodeHelpers = __importStar(require("./NodeHelpers"));
+const ExpressionError_1 = require("./ExpressionError");
 function isResourceLocatorValue(value) {
     return Boolean(typeof value === 'object' && value && 'mode' in value && 'value' in value && '__rl' in value);
 }
@@ -50,12 +51,19 @@ class WorkflowDataProxy {
         luxon_1.Settings.defaultZone = this.timezone;
     }
     nodeContextGetter(nodeName) {
+        var _a;
         const that = this;
         const node = this.workflow.nodes[nodeName];
+        if (!((_a = that.runExecutionData) === null || _a === void 0 ? void 0 : _a.executionData)) {
+            throw new ExpressionError_1.ExpressionError(`The workflow hasn't been executed yet, so you can't reference any context data`, {
+                runIndex: that.runIndex,
+                itemIndex: that.itemIndex,
+            });
+        }
         return new Proxy({}, {
             ownKeys(target) {
                 if (Reflect.ownKeys(target).length === 0) {
-                    Object.assign(target, _1.NodeHelpers.getContext(that.runExecutionData, 'node', node));
+                    Object.assign(target, NodeHelpers.getContext(that.runExecutionData, 'node', node));
                 }
                 return Reflect.ownKeys(target);
             },
@@ -67,10 +75,7 @@ class WorkflowDataProxy {
             },
             get(target, name, receiver) {
                 name = name.toString();
-                const contextData = _1.NodeHelpers.getContext(that.runExecutionData, 'node', node);
-                if (!contextData.hasOwnProperty(name)) {
-                    throw new Error(`Could not find parameter "${name}" on context of node "${nodeName}"`);
-                }
+                const contextData = NodeHelpers.getContext(that.runExecutionData, 'node', node);
                 return contextData[name];
             },
         });
@@ -143,19 +148,19 @@ class WorkflowDataProxy {
         let executionData;
         if (!shortSyntax) {
             if (that.runExecutionData === null) {
-                throw new _1.ExpressionError(`Workflow did not run so do not have any execution-data.`, {
+                throw new ExpressionError_1.ExpressionError(`The workflow hasn't been executed yet, so you can't reference any output data`, {
                     runIndex: that.runIndex,
                     itemIndex: that.itemIndex,
                 });
             }
             if (!that.runExecutionData.resultData.runData.hasOwnProperty(nodeName)) {
                 if (that.workflow.getNode(nodeName)) {
-                    throw new _1.ExpressionError(`The node "${nodeName}" hasn't been executed yet, so you can't reference its output data`, {
+                    throw new ExpressionError_1.ExpressionError(`The node "${nodeName}" hasn't been executed yet, so you can't reference its output data`, {
                         runIndex: that.runIndex,
                         itemIndex: that.itemIndex,
                     });
                 }
-                throw new _1.ExpressionError(`No node called "${nodeName}" in this workflow`, {
+                throw new ExpressionError_1.ExpressionError(`No node called "${nodeName}" in this workflow`, {
                     runIndex: that.runIndex,
                     itemIndex: that.itemIndex,
                 });
@@ -164,14 +169,14 @@ class WorkflowDataProxy {
             runIndex =
                 runIndex === -1 ? that.runExecutionData.resultData.runData[nodeName].length - 1 : runIndex;
             if (that.runExecutionData.resultData.runData[nodeName].length <= runIndex) {
-                throw new _1.ExpressionError(`Run ${runIndex} of node "${nodeName}" not found`, {
+                throw new ExpressionError_1.ExpressionError(`Run ${runIndex} of node "${nodeName}" not found`, {
                     runIndex: that.runIndex,
                     itemIndex: that.itemIndex,
                 });
             }
             const taskData = that.runExecutionData.resultData.runData[nodeName][runIndex].data;
             if (taskData.main === null || !taskData.main.length || taskData.main[0] === null) {
-                throw new _1.ExpressionError(`No data found from "main" input.`, {
+                throw new ExpressionError_1.ExpressionError(`No data found from "main" input.`, {
                     runIndex: that.runIndex,
                     itemIndex: that.itemIndex,
                 });
@@ -179,7 +184,7 @@ class WorkflowDataProxy {
             if (outputIndex === undefined) {
                 const nodeConnection = that.workflow.getNodeConnectionIndexes(that.activeNodeName, nodeName, 'main');
                 if (nodeConnection === undefined) {
-                    throw new _1.ExpressionError(`The node "${that.activeNodeName}" is not connected with node "${nodeName}" so no data can get returned from it.`, {
+                    throw new ExpressionError_1.ExpressionError(`The node "${that.activeNodeName}" is not connected with node "${nodeName}" so no data can get returned from it.`, {
                         runIndex: that.runIndex,
                         itemIndex: that.itemIndex,
                     });
@@ -190,7 +195,7 @@ class WorkflowDataProxy {
                 outputIndex = 0;
             }
             if (taskData.main.length <= outputIndex) {
-                throw new _1.ExpressionError(`Node "${nodeName}" has no branch with index ${outputIndex}.`, {
+                throw new ExpressionError_1.ExpressionError(`Node "${nodeName}" has no branch with index ${outputIndex}.`, {
                     runIndex: that.runIndex,
                     itemIndex: that.itemIndex,
                 });
@@ -214,7 +219,7 @@ class WorkflowDataProxy {
                 if (['binary', 'data', 'json'].includes(name)) {
                     const executionData = that.getNodeExecutionData(nodeName, shortSyntax, undefined);
                     if (executionData.length <= that.itemIndex) {
-                        throw new _1.ExpressionError(`No data found for item-index: "${that.itemIndex}"`, {
+                        throw new ExpressionError_1.ExpressionError(`No data found for item-index: "${that.itemIndex}"`, {
                             runIndex: that.runIndex,
                             itemIndex: that.itemIndex,
                         });
@@ -263,7 +268,7 @@ class WorkflowDataProxy {
         return new Proxy({}, {
             get(target, name, receiver) {
                 if (process.env.N8N_BLOCK_ENV_ACCESS_IN_NODE === 'true') {
-                    throw new _1.ExpressionError('Environment variable access got disabled', {
+                    throw new ExpressionError_1.ExpressionError('Environment variable access got disabled', {
                         causeDetailed: 'If you need access please contact the administrator to remove the environment variable ‘N8N_BLOCK_ENV_ACCESS_IN_NODE‘',
                         runIndex: that.runIndex,
                         itemIndex: that.itemIndex,
@@ -274,6 +279,38 @@ class WorkflowDataProxy {
             },
         });
     }
+    prevNodeGetter() {
+        const allowedValues = ['name', 'outputIndex', 'runIndex'];
+        const that = this;
+        return new Proxy({}, {
+            ownKeys(target) {
+                return allowedValues;
+            },
+            getOwnPropertyDescriptor(k) {
+                return {
+                    enumerable: true,
+                    configurable: true,
+                };
+            },
+            get(target, name, receiver) {
+                var _a, _b;
+                if (!((_a = that.executeData) === null || _a === void 0 ? void 0 : _a.source)) {
+                    return undefined;
+                }
+                const sourceData = (_b = that.executeData) === null || _b === void 0 ? void 0 : _b.source.main[0];
+                if (name === 'name') {
+                    return sourceData.previousNode;
+                }
+                if (name === 'outputIndex') {
+                    return sourceData.previousNodeOutput || 0;
+                }
+                if (name === 'runIndex') {
+                    return sourceData.previousNodeRun || 0;
+                }
+                return Reflect.get(target, name, receiver);
+            },
+        });
+    }
     workflowGetter() {
         const allowedValues = ['active', 'id', 'name'];
         const that = this;
@@ -288,10 +325,19 @@ class WorkflowDataProxy {
                 };
             },
             get(target, name, receiver) {
-                if (!allowedValues.includes(name.toString())) {
-                    throw new Error(`The key "${name.toString()}" is not supported!`);
+                if (allowedValues.includes(name.toString())) {
+                    const value = that.workflow[name];
+                    if (value === undefined && name === 'id') {
+                        throw new ExpressionError_1.ExpressionError('Workflow is not saved', {
+                            description: `Please save the workflow first to use $workflow`,
+                            runIndex: that.runIndex,
+                            itemIndex: that.itemIndex,
+                            failExecution: true,
+                        });
+                    }
+                    return value;
                 }
-                return that.workflow[name];
+                return Reflect.get(target, name, receiver);
             },
         });
     }
@@ -323,23 +369,39 @@ class WorkflowDataProxy {
             }
             return jmespath.search(data, query);
         };
-        const createExpressionError = (message, context, nodeName) => {
-            if (nodeName) {
+        const isFunctionNode = (nodeName) => {
+            const node = that.workflow.getNode(nodeName);
+            return node && ['n8n-nodes-base.function', 'n8n-nodes-base.functionItem'].includes(node.type);
+        };
+        const createExpressionError = (message, context) => {
+            if (isFunctionNode(that.activeNodeName) && (context === null || context === void 0 ? void 0 : context.functionOverrides)) {
+                message = context.functionOverrides.message || message;
+                context.description = context.functionOverrides.description || context.description;
+                context.messageTemplate = undefined;
+            }
+            if (context === null || context === void 0 ? void 0 : context.nodeCause) {
+                const nodeName = context.nodeCause;
                 const pinData = this.workflow.getPinDataOfNode(nodeName);
                 if (pinData) {
                     if (!context) {
                         context = {};
                     }
-                    message = `‘${nodeName}‘ must be unpinned to execute`;
-                    context.description = `To fetch the data the expression needs, The node ‘${nodeName}’ needs to execute without being pinned. <a>Unpin it</a>`;
-                    context.description = `To fetch the data for the expression, you must unpin the node '${nodeName}' and execute the workflow again.`;
-                    context.descriptionTemplate = `To fetch the data for the expression under '%%PARAMETER%%', you must unpin the node '${nodeName}' and execute the workflow again.`;
+                    message = `‘Node ${nodeName}‘ must be unpinned to execute`;
+                    context.messageTemplate = undefined;
+                    context.description = `To fetch the data for the expression, you must unpin the node <strong>'${nodeName}'</strong> and execute the workflow again.`;
+                    context.descriptionTemplate = `To fetch the data for the expression under '%%PARAMETER%%', you must unpin the node <strong>'${nodeName}'</strong> and execute the workflow again.`;
+                }
+                if (context.moreInfoLink && (pinData || isFunctionNode(nodeName))) {
+                    const moreInfoLink = ' <a target="_blank" href="https://docs.n8n.io/data/data-mapping/data-item-linking/item-linking-errors/">More info</a>';
+                    context.description += moreInfoLink;
+                    context.descriptionTemplate += moreInfoLink;
                 }
             }
-            return new _1.ExpressionError(message, {
+            return new ExpressionError_1.ExpressionError(message, {
                 runIndex: that.runIndex,
                 itemIndex: that.itemIndex,
                 failExecution: true,
+                functionality: 'pairedItem',
                 ...context,
             });
         };
@@ -351,6 +413,7 @@ class WorkflowDataProxy {
                     item: pairedItem,
                 };
             }
+            let currentPairedItem = pairedItem;
             let nodeBeforeLast;
             while (sourceData !== null && destinationNodeName !== sourceData.previousNode) {
                 taskData =
@@ -358,25 +421,43 @@ class WorkflowDataProxy {
                 const previousNodeOutput = sourceData.previousNodeOutput || 0;
                 if (previousNodeOutput >= taskData.data.main.length) {
                     throw createExpressionError('Can’t get data for expression', {
-                        messageTemplate: 'Can’t get data for expression under ‘%%PARAMETER%%’',
+                        messageTemplate: 'Can’t get data for expression under ‘%%PARAMETER%%’ field',
+                        functionOverrides: {
+                            message: 'Can’t get data',
+                        },
+                        nodeCause: nodeBeforeLast,
                         description: `Apologies, this is an internal error. See details for more information`,
                         causeDetailed: 'Referencing a non-existent output on a node, problem with source data',
-                    }, nodeBeforeLast);
+                        type: 'internal',
+                    });
                 }
                 if (pairedItem.item >= taskData.data.main[previousNodeOutput].length) {
                     throw createExpressionError('Can’t get data for expression', {
-                        messageTemplate: `Can’t get data for expression under ‘%%PARAMETER%%’`,
-                        description: `Item points to an item which does not exist`,
-                        causeDetailed: `The pairedItem data points to an item ‘${pairedItem.item}‘ which does not exist on node ‘${sourceData.previousNode}‘ (output node did probably supply a wrong one)`,
-                    }, nodeBeforeLast);
+                        messageTemplate: `Can’t get data for expression under ‘%%PARAMETER%%’ field`,
+                        functionOverrides: {
+                            message: 'Can’t get data',
+                        },
+                        nodeCause: nodeBeforeLast,
+                        description: `In node ‘<strong>${nodeBeforeLast}</strong>’, output item ${currentPairedItem.item || 0} ${sourceData.previousNodeRun
+                            ? `of run ${(sourceData.previousNodeRun || 0).toString()} `
+                            : ''}points to an input item on node ‘<strong>${sourceData.previousNode}</strong>‘ that doesn’t exist.`,
+                        type: 'invalid pairing info',
+                        moreInfoLink: true,
+                    });
                 }
                 const itemPreviousNode = taskData.data.main[previousNodeOutput][pairedItem.item];
                 if (itemPreviousNode.pairedItem === undefined) {
                     throw createExpressionError('Can’t get data for expression', {
-                        messageTemplate: `Can’t get data for expression under ‘%%PARAMETER%%’`,
-                        description: `To fetch the data from other nodes that this expression needs, more information is needed from the node ‘${sourceData.previousNode}’`,
-                        causeDetailed: `Missing pairedItem data (node ‘${sourceData.previousNode}’ did probably not supply it)`,
-                    }, sourceData.previousNode);
+                        messageTemplate: `Can’t get data for expression under ‘%%PARAMETER%%’ field`,
+                        functionOverrides: {
+                            message: 'Can’t get data',
+                        },
+                        nodeCause: sourceData.previousNode,
+                        description: `To fetch the data from other nodes that this expression needs, more information is needed from the node ‘<strong>${sourceData.previousNode}</strong>’`,
+                        causeDetailed: `Missing pairedItem data (node ‘${sourceData.previousNode}’ probably didn’t supply it)`,
+                        type: 'no pairing info',
+                        moreInfoLink: true,
+                    });
                 }
                 if (Array.isArray(itemPreviousNode.pairedItem)) {
                     const results = itemPreviousNode.pairedItem
@@ -396,11 +477,17 @@ class WorkflowDataProxy {
                     if (results.length !== 1) {
                         throw createExpressionError('Invalid expression', {
                             messageTemplate: 'Invalid expression under ‘%%PARAMETER%%’',
-                            description: `The expression uses data in node ‘${destinationNodeName}’ but there is more than one matching item in that node`,
+                            functionOverrides: {
+                                description: `The code uses data in the node ‘<strong>${destinationNodeName}</strong>’ but there is more than one matching item in that node`,
+                                message: 'Invalid code',
+                            },
+                            description: `The expression uses data in the node ‘<strong>${destinationNodeName}</strong>’ but there is more than one matching item in that node`,
+                            type: 'multiple matches',
                         });
                     }
                     return results[0];
                 }
+                currentPairedItem = pairedItem;
                 if (typeof itemPreviousNode.pairedItem === 'number') {
                     pairedItem = {
                         item: itemPreviousNode.pairedItem,
@@ -414,136 +501,139 @@ class WorkflowDataProxy {
                     if (taskData.source.length === 0) {
                         throw createExpressionError('Invalid expression', {
                             messageTemplate: 'Invalid expression under ‘%%PARAMETER%%’',
-                            description: `The expression uses data in node ‘${destinationNodeName}’ but there is no path back to it. Please check this node is connected to node ‘${that.activeNodeName}’ (there can be other nodes in between).`,
+                            functionOverrides: {
+                                description: `The code uses data in the node ‘<strong>${destinationNodeName}</strong>’ but there is no path back to it. Please check this node is connected to it (there can be other nodes in between).`,
+                                message: 'Invalid code',
+                            },
+                            description: `The expression uses data in the node ‘<strong>${destinationNodeName}</strong>’ but there is no path back to it. Please check this node is connected to it (there can be other nodes in between).`,
+                            type: 'no connection',
+                            moreInfoLink: true,
                         });
                     }
                     throw createExpressionError('Can’t get data for expression', {
-                        messageTemplate: `Can’t get data for expression under ‘%%PARAMETER%%’`,
-                        description: `Item points to a node input which does not exist`,
-                        causeDetailed: `The pairedItem data points to a node input ‘${itemInput}‘ which does not exist on node ‘${sourceData.previousNode}‘ (node did probably supply a wrong one)`,
-                    }, nodeBeforeLast);
+                        messageTemplate: `Can’t get data for expression under ‘%%PARAMETER%%’ field`,
+                        functionOverrides: {
+                            message: `Can’t get data`,
+                        },
+                        nodeCause: nodeBeforeLast,
+                        description: `In node ‘<strong>${sourceData.previousNode}</strong>’, output item ${currentPairedItem.item || 0} of ${sourceData.previousNodeRun
+                            ? `of run ${(sourceData.previousNodeRun || 0).toString()} `
+                            : ''}points to a branch that doesn’t exist.`,
+                        type: 'invalid pairing info',
+                    });
                 }
                 nodeBeforeLast = sourceData.previousNode;
                 sourceData = taskData.source[pairedItem.input || 0] || null;
             }
             if (sourceData === null) {
                 throw createExpressionError('Can’t get data for expression', {
-                    messageTemplate: `Can’t get data for expression under ‘%%PARAMETER%%’`,
-                    description: `Could not resolve, probably no pairedItem exists`,
-                }, nodeBeforeLast);
+                    messageTemplate: `Can’t get data for expression under ‘%%PARAMETER%%’ field`,
+                    functionOverrides: {
+                        message: `Can’t get data`,
+                    },
+                    nodeCause: nodeBeforeLast,
+                    description: `Could not resolve, proably no pairedItem exists`,
+                    type: 'no pairing info',
+                    moreInfoLink: true,
+                });
             }
             taskData =
                 that.runExecutionData.resultData.runData[sourceData.previousNode][(sourceData === null || sourceData === void 0 ? void 0 : sourceData.previousNodeRun) || 0];
             const previousNodeOutput = sourceData.previousNodeOutput || 0;
             if (previousNodeOutput >= taskData.data.main.length) {
                 throw createExpressionError('Can’t get data for expression', {
-                    messageTemplate: `Can’t get data for expression under ‘%%PARAMETER%%’`,
+                    messageTemplate: `Can’t get data for expression under ‘%%PARAMETER%%’ field`,
+                    functionOverrides: {
+                        message: `Can’t get data`,
+                    },
                     description: `Item points to a node output which does not exist`,
                     causeDetailed: `The sourceData points to a node output ‘${previousNodeOutput}‘ which does not exist on node ‘${sourceData.previousNode}‘ (output node did probably supply a wrong one)`,
+                    type: 'invalid pairing info',
                 });
             }
             if (pairedItem.item >= taskData.data.main[previousNodeOutput].length) {
                 throw createExpressionError('Can’t get data for expression', {
-                    messageTemplate: `Can’t get data for expression under ‘%%PARAMETER%%’`,
-                    description: `Item points to an item which does not exist`,
-                    causeDetailed: `The pairedItem data points to an item ‘${pairedItem.item}‘ which does not exist on node ‘${sourceData.previousNode}‘ (output node did probably supply a wrong one)`,
-                }, nodeBeforeLast);
+                    messageTemplate: `Can’t get data for expression under ‘%%PARAMETER%%’ field`,
+                    functionOverrides: {
+                        message: `Can’t get data`,
+                    },
+                    nodeCause: nodeBeforeLast,
+                    description: `In node ‘<strong>${nodeBeforeLast}</strong>’, output item ${currentPairedItem.item || 0} ${sourceData.previousNodeRun
+                        ? `of run ${(sourceData.previousNodeRun || 0).toString()} `
+                        : ''}points to an input item on node ‘<strong>${sourceData.previousNode}</strong>‘ that doesn’t exist.`,
+                    type: 'invalid pairing info',
+                    moreInfoLink: true,
+                });
             }
             return taskData.data.main[previousNodeOutput][pairedItem.item];
         };
         const base = {
             $: (nodeName) => {
                 if (!nodeName) {
-                    throw new _1.ExpressionError('When calling $(), please specify a node', {
-                        runIndex: that.runIndex,
-                        itemIndex: that.itemIndex,
-                        failExecution: true,
-                    });
+                    throw createExpressionError('When calling $(), please specify a node');
+                }
+                const referencedNode = that.workflow.getNode(nodeName);
+                if (referencedNode === null) {
+                    throw createExpressionError(`No node called ‘${nodeName}‘`);
                 }
                 return new Proxy({}, {
                     get(target, property, receiver) {
                         var _a;
-                        if (property === 'pairedItem') {
-                            return (itemIndex) => {
+                        if (['pairedItem', 'itemMatching', 'item'].includes(property)) {
+                            const pairedItemMethod = (itemIndex) => {
                                 var _a, _b;
                                 if (itemIndex === undefined) {
+                                    if (property === 'itemMatching') {
+                                        throw createExpressionError('Missing item index for .itemMatching()', {
+                                            itemIndex,
+                                        });
+                                    }
                                     itemIndex = that.itemIndex;
                                 }
                                 const executionData = that.connectionInputData;
                                 const pairedItem = executionData[itemIndex].pairedItem;
                                 if (pairedItem === undefined) {
-                                    throw new _1.ExpressionError('Can’t get data for expression', {
-                                        messageTemplate: `Can’t get data for expression under ‘%%PARAMETER%%’`,
-                                        description: `To fetch the data from other nodes that this expression needs, more information is needed from the node ‘${that.activeNodeName}‘`,
-                                        causeDetailed: `Missing pairedItem data (node ‘${that.activeNodeName}‘ did probably not supply it)`,
-                                        runIndex: that.runIndex,
+                                    throw createExpressionError('Can’t get data for expression', {
+                                        messageTemplate: `Can’t get data for expression under ‘%%PARAMETER%%’ field`,
+                                        functionOverrides: {
+                                            description: `To fetch the data from other nodes that this code needs, more information is needed from the node ‘<strong>${that.activeNodeName}</strong>‘`,
+                                            message: `Can’t get data`,
+                                        },
+                                        description: `To fetch the data from other nodes that this expression needs, more information is needed from the node ‘<strong>${that.activeNodeName}</strong>‘`,
+                                        causeDetailed: `Missing pairedItem data (node ‘${that.activeNodeName}‘ probably didn’t supply it)`,
                                         itemIndex,
-                                        failExecution: true,
                                     });
                                 }
                                 if (!((_a = that.executeData) === null || _a === void 0 ? void 0 : _a.source)) {
-                                    throw new _1.ExpressionError('Can’t get data for expression', {
-                                        messageTemplate: 'Can’t get data for expression under ‘%%PARAMETER%%’',
+                                    throw createExpressionError('Can’t get data for expression', {
+                                        messageTemplate: 'Can’t get data for expression under ‘%%PARAMETER%%’ field',
+                                        functionOverrides: {
+                                            message: `Can’t get data`,
+                                        },
                                         description: `Apologies, this is an internal error. See details for more information`,
                                         causeDetailed: `Missing sourceData (probably an internal error)`,
-                                        runIndex: that.runIndex,
                                         itemIndex,
-                                        failExecution: true,
                                     });
                                 }
                                 const parentNodes = that.workflow.getParentNodes(that.activeNodeName);
                                 if (!parentNodes.includes(nodeName)) {
-                                    throw new _1.ExpressionError('Invalid expression', {
+                                    throw createExpressionError('Invalid expression', {
                                         messageTemplate: 'Invalid expression under ‘%%PARAMETER%%’',
-                                        description: `The expression uses data in node ‘${nodeName}’ but there is no path back to it. Please check this node is connected to node ‘${that.activeNodeName}’ (there can be other nodes in between).`,
-                                        runIndex: that.runIndex,
+                                        functionOverrides: {
+                                            description: `The code uses data in the node <strong>‘${nodeName}’</strong> but there is no path back to it. Please check this node is connected to it (there can be other nodes in between).`,
+                                            message: `No path back to node ‘${nodeName}’`,
+                                        },
+                                        description: `The expression uses data in the node <strong>‘${nodeName}’</strong> but there is no path back to it. Please check this node is connected to it (there can be other nodes in between).`,
                                         itemIndex,
-                                        failExecution: true,
                                     });
                                 }
                                 const sourceData = (_b = that.executeData) === null || _b === void 0 ? void 0 : _b.source.main[pairedItem.input || 0];
                                 return getPairedItem(nodeName, sourceData, pairedItem);
                             };
-                        }
-                        if (property === 'item') {
-                            return (itemIndex, branchIndex, runIndex) => {
-                                if (itemIndex === undefined) {
-                                    itemIndex = that.itemIndex;
-                                    branchIndex = 0;
-                                    runIndex = that.runIndex;
-                                }
-                                const executionData = getNodeOutput(nodeName, branchIndex, runIndex);
-                                if (executionData[itemIndex]) {
-                                    return executionData[itemIndex];
-                                }
-                                let errorMessage = '';
-                                if (branchIndex === undefined && runIndex === undefined) {
-                                    errorMessage = `
-											No item found at index ${itemIndex}
-											(for node "${nodeName}")`;
-                                    throw new Error(errorMessage);
-                                }
-                                if (branchIndex === undefined) {
-                                    errorMessage = `
-											No item found at index ${itemIndex}
-											in run ${runIndex || that.runIndex}
-											(for node "${nodeName}")`;
-                                    throw new Error(errorMessage);
-                                }
-                                if (runIndex === undefined) {
-                                    errorMessage = `
-											No item found at index ${itemIndex}
-											of branch ${branchIndex || 0}
-											(for node "${nodeName}")`;
-                                    throw new Error(errorMessage);
-                                }
-                                errorMessage = `
-										No item found at index ${itemIndex}
-										of branch ${branchIndex || 0}
-										in run ${runIndex || that.runIndex}
-										(for node "${nodeName}")`;
-                                throw new Error(errorMessage);
-                            };
+                            if (property === 'item') {
+                                return pairedItemMethod();
+                            }
+                            return pairedItemMethod;
                         }
                         if (property === 'first') {
                             return (branchIndex, runIndex) => {
@@ -578,23 +668,25 @@ class WorkflowDataProxy {
                 });
             },
             $input: new Proxy({}, {
+                ownKeys(target) {
+                    return ['all', 'context', 'first', 'item', 'last', 'params'];
+                },
+                getOwnPropertyDescriptor(k) {
+                    return {
+                        enumerable: true,
+                        configurable: true,
+                    };
+                },
                 get(target, property, receiver) {
-                    if (property === 'thisItem') {
-                        return that.connectionInputData[that.itemIndex];
-                    }
+                    var _a, _b, _c;
                     if (property === 'item') {
-                        return (itemIndex) => {
-                            if (itemIndex === undefined)
-                                itemIndex = that.itemIndex;
-                            const result = that.connectionInputData;
-                            if (result[itemIndex]) {
-                                return result[itemIndex];
-                            }
-                            return undefined;
-                        };
+                        return that.connectionInputData[that.itemIndex];
                     }
                     if (property === 'first') {
-                        return () => {
+                        return (...args) => {
+                            if (args.length) {
+                                throw createExpressionError('$input.first() should have no arguments');
+                            }
                             const result = that.connectionInputData;
                             if (result[0]) {
                                 return result[0];
@@ -603,7 +695,10 @@ class WorkflowDataProxy {
                         };
                     }
                     if (property === 'last') {
-                        return () => {
+                        return (...args) => {
+                            if (args.length) {
+                                throw createExpressionError('$input.last() should have no arguments');
+                            }
                             const result = that.connectionInputData;
                             if (result.length && result[result.length - 1]) {
                                 return result[result.length - 1];
@@ -620,10 +715,29 @@ class WorkflowDataProxy {
                             return [];
                         };
                     }
+                    if (['context', 'params'].includes(property)) {
+                        if (!((_a = that.executeData) === null || _a === void 0 ? void 0 : _a.source)) {
+                            throw createExpressionError('Can’t get data for expression', {
+                                messageTemplate: 'Can’t get data for expression under ‘%%PARAMETER%%’ field',
+                                functionOverrides: {
+                                    message: 'Can’t get data',
+                                },
+                                description: `Apologies, this is an internal error. See details for more information`,
+                                causeDetailed: `Missing sourceData (probably an internal error)`,
+                                runIndex: that.runIndex,
+                            });
+                        }
+                        const sourceData = (_b = that.executeData) === null || _b === void 0 ? void 0 : _b.source.main[0];
+                        if (property === 'context') {
+                            return that.nodeContextGetter(sourceData.previousNode);
+                        }
+                        if (property === 'params') {
+                            return (_c = that.workflow.getNode(sourceData.previousNode)) === null || _c === void 0 ? void 0 : _c.parameters;
+                        }
+                    }
                     return Reflect.get(target, property, receiver);
                 },
             }),
-            $thisItem: that.connectionInputData[that.itemIndex],
             $binary: {},
             $data: {},
             $env: this.envGetter(),
@@ -652,19 +766,23 @@ class WorkflowDataProxy {
             $node: this.nodeGetter(),
             $self: this.selfGetter(),
             $parameter: this.nodeParameterGetter(this.activeNodeName),
-            $position: this.itemIndex,
+            $prevNode: this.prevNodeGetter(),
             $runIndex: this.runIndex,
             $mode: this.mode,
             $workflow: this.workflowGetter(),
-            $thisRunIndex: this.runIndex,
-            $thisItemIndex: this.itemIndex,
+            $itemIndex: this.itemIndex,
             $now: luxon_1.DateTime.now(),
             $today: luxon_1.DateTime.now().set({ hour: 0, minute: 0, second: 0, millisecond: 0 }),
-            $jmespath: jmespathWrapper,
+            $jmesPath: jmespathWrapper,
             DateTime: luxon_1.DateTime,
             Interval: luxon_1.Interval,
             Duration: luxon_1.Duration,
             ...that.additionalKeys,
+            $jmespath: jmespathWrapper,
+            $position: this.itemIndex,
+            $thisItem: that.connectionInputData[that.itemIndex],
+            $thisItemIndex: this.itemIndex,
+            $thisRunIndex: this.runIndex,
         };
         return new Proxy(base, {
             get(target, name, receiver) {