Skip to content

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

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.ts
index 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 = 1
const 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>): unk
let value: unknown = sampleData
for (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.ts
index 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)))
: 0
return 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)))
: 0
return 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))
: item
if (seen.has(key)) return false
seen.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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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`