feat: Expression extension framework

.vscode/launch.json

@@ -5,6 +5,17 @@
 	"version": "0.2.0",
 	"configurations": [
 		{
+      "type": "node",
+      "request": "launch",
+      "name": "Jest: current file",
+      "program": "${workspaceFolder}/node_modules/.bin/jest",
+      "args": ["${fileBasenameNoExtension}"],
+      "console": "integratedTerminal",
+      "windows": {
+        "program": "${workspaceFolder}/node_modules/jest/bin/jest"
+      }
+    },
+		{
 			"name": "Attach to running n8n",
 			"processId": "${command:PickProcess}",
 			"request": "attach",

packages/editor-ui/tsconfig.json

@@ -9,6 +9,7 @@
 		"allowJs": true,
 		"importHelpers": true,
 		"allowSyntheticDefaultImports": true,
+		"resolveJsonModule": true,
 		"baseUrl": ".",
 		"types": ["vitest/globals"],
 		"paths": {

packages/editor-ui/vite.config.ts

@@ -38,6 +38,10 @@ const lodashAliases = ['orderBy', 'camelCase', 'cloneDeep', 'isEqual'].map(name
 
 export default mergeConfig(
 	defineConfig({
+		define: {
+			// This causes test to fail but is required for actually running it
+			...(process.env.NODE_ENV !== 'test' ? { global: 'globalThis' } : {}),
+		},
 		plugins: [
 			legacy({
 				targets: ['defaults', 'not IE 11'],

packages/workflow/package.json

@@ -38,6 +38,7 @@
   ],
   "devDependencies": {
     "@n8n_io/eslint-config": "",
+    "@types/crypto-js": "^4.1.1",
     "@types/express": "^4.17.6",
     "@types/jmespath": "^0.15.0",
     "@types/lodash.get": "^4.4.6",
@@ -51,12 +52,15 @@
   },
   "dependencies": {
     "@n8n_io/riot-tmpl": "^1.0.1",
+    "crypto-js": "^4.1.1",
     "jmespath": "^0.16.0",
+    "js-base64": "^3.7.2",
     "lodash.get": "^4.4.2",
     "lodash.isequal": "^4.5.0",
     "lodash.merge": "^4.6.2",
     "lodash.set": "^4.3.2",
     "luxon": "~2.3.0",
+    "recast": "^0.21.5",
     "xml2js": "^0.4.23"
   }
 }

packages/workflow/src/Expression.ts

@@ -14,10 +14,20 @@ import {
 	NodeParameterValueType,
 	WorkflowExecuteMode,
 } from './Interfaces';
-import { ExpressionError } from './ExpressionError';
+import { ExpressionError, ExpressionExtensionError } from './ExpressionError';
 import { WorkflowDataProxy } from './WorkflowDataProxy';
 import type { Workflow } from './Workflow';
 
+// eslint-disable-next-line import/no-cycle
+import { extend, hasExpressionExtension, hasNativeMethod } from './Extensions';
+import {
+	ExpressionChunk,
+	ExpressionCode,
+	joinExpression,
+	splitExpression,
+} from './Extensions/ExpressionParser';
+import { extendTransform } from './Extensions/ExpressionExtension';
+
 // Set it to use double curly brackets instead of single ones
 tmpl.brackets.set('{{ }}');
 
@@ -242,6 +252,9 @@ export class Expression {
 		data.Boolean = Boolean;
 		data.Symbol = Symbol;
 
+		// expression extensions
+		data.extend = extend;
+
 		const constructorValidation = new RegExp(/\.\s*constructor/gm);
 		if (parameterValue.match(constructorValidation)) {
 			throw new ExpressionError('Expression contains invalid constructor function call', {
@@ -252,7 +265,8 @@ export class Expression {
 		}
 
 		// Execute the expression
-		const returnValue = this.renderExpression(parameterValue, data);
+		const extendedExpression = this.extendSyntax(parameterValue);
+		const returnValue = this.renderExpression(extendedExpression, data);
 		if (typeof returnValue === 'function') {
 			throw new Error('Expression resolved to a function. Please add "()"');
 		} else if (typeof returnValue === 'string') {
@@ -266,7 +280,10 @@ export class Expression {
 		return returnValue;
 	}
 
-	private renderExpression(expression: string, data: IWorkflowDataProxyData): tmpl.ReturnValue {
+	private renderExpression(
+		expression: string,
+		data: IWorkflowDataProxyData,
+	): tmpl.ReturnValue | undefined {
 		try {
 			return tmpl.tmpl(expression, data);
 		} catch (error) {
@@ -278,7 +295,41 @@ export class Expression {
 				}
 			}
 		}
-		return null;
+		return undefined;
+	}
+
+	extendSyntax(bracketedExpression: string): string {
+		if (!hasExpressionExtension(bracketedExpression) || hasNativeMethod(bracketedExpression))
+			return bracketedExpression;
+
+		const chunks = splitExpression(bracketedExpression);
+
+		const extendedChunks = chunks.map((chunk): ExpressionChunk => {
+			if (chunk.type === 'code') {
+				const output = extendTransform(chunk.text);
+
+				// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+				if (!output?.code) {
+					throw new ExpressionExtensionError('Failed to extend syntax');
+				}
+
+				let text = output.code;
+				// We need to cut off any trailing semicolons. These cause issues
+				// with certain types of expression and cause the whole expression
+				// to fail.
+				if (text.trim().endsWith(';')) {
+					text = text.trim().slice(0, -1);
+				}
+
+				return {
+					...chunk,
+					text,
+				} as ExpressionCode;
+			}
+			return chunk;
+		});
+
+		return joinExpression(extendedChunks);
 	}
 
 	/**
@@ -437,6 +488,7 @@ export class Expression {
 					selfData,
 				);
 			}
+
 			return this.resolveSimpleParameterValue(
 				value as NodeParameterValue,
 				siblingParameters,

packages/workflow/src/ExpressionError.ts

@@ -51,3 +51,10 @@ export class ExpressionError extends ExecutionBaseError {
 		}
 	}
 }
+
+export class ExpressionExtensionError extends ExpressionError {
+	constructor(message: string) {
+		super(message);
+		this.context.failExecution = true;
+	}
+}

packages/workflow/src/Extensions/ArrayExtensions.ts

@@ -0,0 +1,81 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/unbound-method */
+/* eslint-disable @typescript-eslint/explicit-member-accessibility */
+// eslint-disable-next-line import/no-cycle
+import { ExpressionError } from '../ExpressionError';
+import { ExtensionMap } from './Extensions';
+// import { BaseExtension, ExtensionMethodHandler } from './Extensions';
+
+function filter(value: any[], extraArgs?: any[]): any[] {
+	if (!Array.isArray(extraArgs)) {
+		throw new ExpressionError('arguments must be passed to filter');
+	}
+	const terms = extraArgs as string[] | number[];
+	return value.filter((v: string | number) => (terms as Array<typeof v>).includes(v));
+}
+
+function first(value: any[]): any {
+	return value[0];
+}
+
+function isBlank(value: any[]): boolean {
+	return value.length === 0;
+}
+
+function isPresent(value: any[]): boolean {
+	return value.length > 0;
+}
+
+function last(value: any[]): any {
+	return value[value.length - 1];
+}
+
+function length(value: any[]): number {
+	return Array.isArray(value) ? value.length : 0;
+}
+
+function pluck(value: any[], extraArgs: any[]): any[] {
+	if (!Array.isArray(extraArgs)) {
+		throw new ExpressionError('arguments must be passed to pluck');
+	}
+	const fieldsToPluck = extraArgs;
+	return value.map((element: object) => {
+		const entries = Object.entries(element);
+		return entries.reduce((p, c) => {
+			const [key, val] = c as [string, Date | string | number];
+			if (fieldsToPluck.includes(key)) {
+				Object.assign(p, { [key]: val });
+			}
+			return p;
+		}, {});
+	});
+}
+
+function random(value: any[]): any {
+	const len = value === undefined ? 0 : value.length;
+	return len ? value[Math.floor(Math.random() * len)] : undefined;
+}
+
+function unique(value: any[]): any[] {
+	return Array.from(new Set(value));
+}
+
+export const arrayExtensions: ExtensionMap = {
+	typeName: 'Array',
+	functions: {
+		count: length,
+		duplicates: unique,
+		filter,
+		first,
+		last,
+		length,
+		pluck,
+		unique,
+		random,
+		randomItem: random,
+		remove: unique,
+		size: length,
+		isPresent,
+		isBlank,
+	},
+};