AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents
TypeScript ai-agentai-agent-toolsai-agentsai-agents-frameworkmcpmcp-servermcp-toolsmcpsn8n-alternativeno-code-automationworkflowworkflow-automationworkflows
fix(formula): resolve formula names and fields from own properties only
KhaledR5738da1660f224
diff --git a/packages/core/formula/src/lib/formula-evaluator.ts b/packages/core/formula/src/lib/formula-evaluator.tsindex f03fbdb3e72..9a442e5878a 100644--- a/packages/core/formula/src/lib/formula-evaluator.ts+++ b/packages/core/formula/src/lib/formula-evaluator.ts@@ -1,5 +1,6 @@import { evaluateRaw } from './function-implementations'import { AP_FUNCTIONS } from './function-registry'+import { ownValue } from './own-value'const CURRENT_FORMULA_VERSION = 1const FORMULA_PREFIX = `ap-formula-v${CURRENT_FORMULA_VERSION}::{`@@ -323,8 +324,8 @@ function friendlyError(e: unknown): string {if (/parse error|Expected EOF|unexpected token|value expected|unexpected \)/i.test(msg)) {return 'Invalid formula — check for empty values or mismatched parentheses'}- if (/is not defined/i.test(msg)) {- const m = msg.match(/(\w+) is not defined/)+ if (/is not defined|undefined variable/i.test(msg)) {+ const m = msg.match(/(\w+) is not defined/) ?? msg.match(/undefined variable: (\w+)/)return m? `"${m[1]}" is not a known function or variable — check for typos`: 'Unknown function or variable — check for typos'@@ -350,7 +351,7 @@ function resolveVariable(path: string, sampleData: Record<string, unknown>): unklet value: unknown = sampleDatafor (const part of parts) {if (value == null || typeof value !== 'object') return undefined- value = (value as Record<string, unknown>)[part]+ value = ownValue.read({ source: value, key: part })}return value}diff --git a/packages/core/formula/src/lib/function-implementations.ts b/packages/core/formula/src/lib/function-implementations.tsindex f7896714069..50008ab8f32 100644--- a/packages/core/formula/src/lib/function-implementations.ts+++ b/packages/core/formula/src/lib/function-implementations.ts@@ -4,6 +4,7 @@ import timezoneDayjs from 'dayjs/plugin/timezone'import utcDayjs from 'dayjs/plugin/utc'import { Parser } from 'expr-eval'import { AP_FUNCTIONS } from './function-registry'+import { ownValue } from './own-value'dayjs.extend(relativeTimeDayjs)dayjs.extend(timezoneDayjs)@@ -19,15 +20,33 @@ declare module 'expr-eval' {interface Parser {evaluate(expression: string, values: Record<string, unknown>): unknown}+ // eslint-disable-next-line @typescript-eslint/consistent-type-definitions+ interface Expression {+ evaluate(values: Record<string, unknown>): unknown+ }}// Parser is a module-private singleton — exposing it would let any consumer// of @activepieces/shared mutate `parser.functions.X` and break formula// evaluation process-wide. Use `evaluateRaw` instead.-const parser = new Parser()+const parser = new Parser({+ allowMemberAccess: false,+ operators: withoutPrototype({+ fndef: false,+ }),+})+for (const table of [parser.functions, parser.consts, parser.unaryOps, Reflect.get(parser, 'binaryOps'), Reflect.get(parser, 'ternaryOps')]) {+ Object.setPrototypeOf(table, null)+}export function evaluateRaw(expression: string, vars: Record<string, unknown>): unknown {- return parser.evaluate(expression, vars)+ const scope = withoutPrototype(vars)+ const parsed = parser.parse(expression)+ const inheritedName = parsed.symbols().find((symbol) => isInheritedName({ symbol, scope }))+ if (inheritedName !== undefined) {+ throw new Error(`${inheritedName} is not defined`)+ }+ return parsed.evaluate(scope)}parser.functions.combine = (a: unknown, b: unknown, sep: unknown = '') =>@@ -296,7 +315,7 @@ parser.functions.filter_list = (list: unknown, field: unknown, value: unknown) =// input, while item fields are typed (`{age: 25}`). `===` would silently// return zero matches when filtering numeric fields with string args.// Same rationale applies to is_equal, switch, if_null below.- (item as Record<string, unknown>)[String(field)] == value,+ readField(item, String(field)) == value,)parser.functions.sort_list = (list: unknown, field: unknown, order: unknown = 'asc') => {const arr = [...toArray(list)]@@ -313,11 +332,7 @@ parser.functions.sort_list = (list: unknown, field: unknown, order: unknown = 'a})}parser.functions.pluck = (list: unknown, field: unknown) =>- toArray(list).map((item) =>- typeof item === 'object' && item !== null- ? (item as Record<string, unknown>)[String(field)]- : undefined,- )+ toArray(list).map((item) => readField(item, String(field)))parser.functions.join_list = (list: unknown, sep: unknown = ',') =>toArray(list).join(String(sep))parser.functions.first_item = (list: unknown) => toArray(list)[0]@@ -332,7 +347,7 @@ parser.functions.sum = (list: unknown, field: unknown) => {return toArray(list).reduce<number>((acc, item) => {const v =typeof item === 'object' && item !== null- ? Number((item as Record<string, unknown>)[String(field)])+ ? Number(readField(item, String(field))): 0return acc + (isNaN(v) ? 0 : v)}, 0)@@ -343,7 +358,7 @@ parser.functions.average = (list: unknown, field: unknown) => {const total = arr.reduce<number>((acc, item) => {const v =typeof item === 'object' && item !== null- ? Number((item as Record<string, unknown>)[String(field)])+ ? Number(readField(item, String(field))): 0return acc + (isNaN(v) ? 0 : v)}, 0)@@ -362,7 +377,7 @@ parser.functions.deduplicate = (list: unknown, field: unknown) => {return toArray(list).filter((item) => {const key =typeof item === 'object' && item !== null- ? (item as Record<string, unknown>)[String(field)]+ ? readField(item, String(field)): itemif (seen.has(key)) return falseseen.add(key)@@ -431,10 +446,15 @@ function toArray(value: unknown): unknown[] {}function readField(item: unknown, field: string): unknown {- if (item !== null && typeof item === 'object') {- return (item as Record<string, unknown>)[field]- }- return undefined+ return ownValue.read({ source: item, key: field })+}++function withoutPrototype<T extends object>(source: T): T {+ return Object.assign(Object.create(null), source)+}++function isInheritedName({ symbol, scope }: { symbol: string, scope: Record<string, unknown> }): boolean {+ return symbol in Object.prototype && !Object.hasOwn(scope, symbol) && !Object.hasOwn(parser.functions, symbol)}function toNumericFieldValues(list: unknown, field: unknown): number[] {diff --git a/packages/core/formula/src/lib/own-value.ts b/packages/core/formula/src/lib/own-value.tsnew file mode 100644index 00000000000..4e210b7d98c--- /dev/null+++ b/packages/core/formula/src/lib/own-value.ts@@ -0,0 +1,10 @@+function read({ source, key }: { source: unknown, key: string }): unknown {+ if (source === null || typeof source !== 'object') {+ return undefined+ }+ return Object.getOwnPropertyDescriptor(source, key)?.value+}++export const ownValue = {+ read,+}diff --git a/packages/server/engine/test/variables/formula-scope.test.ts b/packages/server/engine/test/variables/formula-scope.test.tsnew file mode 100644index 00000000000..e1d62d4231f--- /dev/null+++ b/packages/server/engine/test/variables/formula-scope.test.ts@@ -0,0 +1,106 @@+import { formulaEvaluator } from '@activepieces/core-formula'+import { LATEST_CONTEXT_VERSION } from '@activepieces/pieces-framework'+import { afterEach, beforeEach, describe, expect, test } from 'vitest'+import { FlowExecutorContext } from '../../src/lib/handler/context/flow-execution-context'+import { createPropsResolver } from '../../src/lib/variables/props-resolver'++const propsResolverService = createPropsResolver({+ projectId: 'PROJECT_ID',+ engineToken: 'WORKER_TOKEN',+ apiUrl: 'http://127.0.0.1:3000',+ contextVersion: LATEST_CONTEXT_VERSION,+ stepNames: ['trigger'],+})++let prototypeKeysBefore: string[] = []++beforeEach(() => {+ prototypeKeysBefore = Object.getOwnPropertyNames(Object.prototype).sort()+})++afterEach(() => {+ const leakedMarker = Reflect.get(globalThis, MARKER)+ Reflect.deleteProperty(globalThis, MARKER)+ const addedPrototypeKeys = Object.getOwnPropertyNames(Object.prototype).filter((key) => !prototypeKeysBefore.includes(key))+ addedPrototypeKeys.forEach((key) => Reflect.deleteProperty(Object.prototype, key))+ expect(addedPrototypeKeys).toEqual([])+ expect(leakedMarker).toBeUndefined()+})++describe('formula scope', () => {+ test.each([+ ['list helper returning Object', `((first_item(pluck([{"a":1}]; "constructor"))).getOwnPropertyDescriptor((first_item(pluck([{"a":1}]; "constructor"))).getPrototypeOf(uppercase); "constructor")).value("${SET_MARKER}")()`],+ ['assigned constructor', `((x = constructor).getOwnPropertyDescriptor(x.__proto__, "constructor")).value("${SET_MARKER}")()`],+ ['assigned constructor with prototype write', `(o = constructor) ? (o.assign(__proto__, o.getOwnPropertyDescriptor(o.getPrototypeOf(toString), "constructor")) ? value("delete Object.prototype.value; ${SET_MARKER}")() : 0) : 0`],+ ])('refuses to run code through %s', async (_name, expression) => {+ await expect(propsResolverService.resolve({+ unresolvedInput: formulaEvaluator.wrap(expression),+ executionState: FlowExecutorContext.empty(),+ })).rejects.toThrow(/Formula error/)+ })++ test.each(['constructor', '__proto__', 'toString', 'hasOwnProperty', '__defineGetter__', 'constructor 1', 'valueOf(1)', 'x = constructor', '__proto__ = 1'])('does not resolve inherited name in %s', (expression) => {+ const { result, error } = evaluate({ expression })+ expect(result).toBeNull()+ expect(error).not.toBeNull()+ })++ test.each(['uppercase.constructor', '"abc".constructor', 'f(x) = x; f(1)'])('rejects %s', (expression) => {+ expect(evaluate({ expression }).error).not.toBeNull()+ })++ test.each(['pluck', 'filter_list', 'sort_list', 'deduplicate', 'sum', 'average', 'max_in_list', 'min_in_list'])('%s ignores inherited keys', (fn) => {+ const args = fn === 'filter_list' ? '[{"a":1}]; "constructor"; "x"' : '[{"a":1},{"a":2}]; "constructor"'+ const { result, error } = evaluate({ expression: `${fn}(${args})` })+ expect(error).toBeNull()+ expect(containsFunction(result)).toBe(false)+ })++ test('list helpers still read own keys named like inherited ones', () => {+ expect(evaluate({ expression: 'pluck([{"constructor":"x"},{"toString":"y"}]; "constructor")' }).result).toEqual(['x', undefined])+ })++ test.each(['{{user.constructor}}', '{{user.__proto__}}', '{{user.toString}}', '{{constructor}}', '{{user.constructor.constructor}}'])('mention %s does not expose inherited values', (expression) => {+ const { result } = evaluate({ expression, sampleData: { user: { name: 'Ada' } } })+ expect(containsFunction(result)).toBe(false)+ expect(result).not.toBe(Object.prototype)+ })++ test('mentions still read own keys named like inherited ones', () => {+ expect(evaluate({ expression: 'uppercase({{user.constructor}})', sampleData: { user: { constructor: 'own value' } } }).result).toBe('OWN VALUE')+ })++ test('unknown names report the name', () => {+ expect(evaluate({ expression: 'tickets' }).error).toBe('"tickets" is not a known function or variable — check for typos')+ })++ test.each([+ ['map(uppercase, ["a", "b"])', ['A', 'B']],+ ['fold(add, 0, [1, 2, 3])', 6],+ ['floor(2.7) + abs(-1)', 3],+ ['if({{age}} >= 18; "adult"; "minor")', 'adult'],+ ['pluck({{orders}}; "total")', [10, 20]],+ ['true ? 1 : unknown_name', 1],+ ['map(!, [3])', [6]],+ ['x = 1', 1],+ ])('keeps %s working', (expression, expected) => {+ expect(evaluate({ expression, sampleData: { age: 30, orders: [{ total: 10 }, { total: 20 }] } }).result).toEqual(expected)+ })+})++function evaluate({ expression, sampleData = {} }: { expression: string, sampleData?: Record<string, unknown> }): ReturnType<typeof formulaEvaluator.evaluate> {+ return formulaEvaluator.evaluate({ expression: formulaEvaluator.wrap(expression), sampleData })+}++function containsFunction(value: unknown): boolean {+ if (typeof value === 'function') {+ return true+ }+ if (value === null || typeof value !== 'object') {+ return false+ }+ return Object.values(value).some(containsFunction)+}++const MARKER = '__formula_scope_marker'+const SET_MARKER = `globalThis.${MARKER} = 1; return 1`