feat: Implement missing macros (Fix) (#61)

Co-authored-by: Karol <[email protected]>

Author: Jastrzebowski

demo/demo.ts

@@ -43,12 +43,55 @@ import { evaluate, parse } from 'cel-js'
 
   // Macro expressions
   // size()
-  const macroExpr = 'size([1, 2])'
-  console.log(`${macroExpr} => ${evaluate(macroExpr)}`) // => 2
+  const sizeMacroExpr = 'size([1, 2])'
+  console.log(`${sizeMacroExpr} => ${evaluate(sizeMacroExpr)}`) // => 2
 
   // has()
-  const hasExpr = 'has(user.role)'
-  console.log(`${hasExpr} => ${evaluate(hasExpr, context)}`) // => true
+  const hasMacroExpr = 'has(user.role)'
+  console.log(`${hasMacroExpr} => ${evaluate(hasMacroExpr, context)}`) // => true
+
+  // Collection macro context
+  const collectionContext = {
+    numbers: [1, 2, 3, 4, 5],
+    scores: { alice: 85, bob: 92, charlie: 78 },
+    people: [
+      { name: 'Alice', age: 25 },
+      { name: 'Bob', age: 30 },
+      { name: 'Charlie', age: 35 },
+    ],
+  }
+
+  // Collection macros - filter()
+  const filterMacroExpr = 'numbers.filter(n, n > 3)'
+  console.log(`${filterMacroExpr} => ${evaluate(filterMacroExpr, collectionContext)}`) // => [4, 5]
+
+  // Collection macros - map()
+  const mapMacroExpr = 'numbers.map(n, n * 2)'
+  console.log(`${mapMacroExpr} => ${evaluate(mapMacroExpr, collectionContext)}`) // => [2, 4, 6, 8, 10]
+
+  // Collection macros - all()
+  const allMacroExpr = 'numbers.all(n, n > 0)'
+  console.log(`${allMacroExpr} => ${evaluate(allMacroExpr, collectionContext)}`) // => true
+
+  // Collection macros - exists()
+  const existsMacroExpr = 'numbers.exists(n, n > 5)'
+  console.log(`${existsMacroExpr} => ${evaluate(existsMacroExpr, collectionContext)}`) // => false
+
+  // Collection macros - exists_one()
+  const existsOneMacroExpr = 'numbers.exists_one(n, n == 5)'
+  console.log(`${existsOneMacroExpr} => ${evaluate(existsOneMacroExpr, collectionContext)}`) // => true
+
+  // Collection macros on maps
+  const mapFilterExpr = 'scores.filter(name, scores[name] > 80)'
+  console.log(`${mapFilterExpr} => ${evaluate(mapFilterExpr, collectionContext)}`) // => ['alice', 'bob']
+
+  // Collection macros - map with predicate (3 arguments)
+  const mapWithPredicateExpr = 'numbers.map(n, n > 3, n * 10)'
+  console.log(`${mapWithPredicateExpr} => ${evaluate(mapWithPredicateExpr, collectionContext)}`) // => [40, 50]
+
+  // Collection macros - extract properties
+  const extractPropsExpr = 'people.map(person, person.name)'
+  console.log(`${extractPropsExpr} => ${evaluate(extractPropsExpr, collectionContext)}`) // => ['Alice', 'Bob', 'Charlie']
 
   // Custom function expressions
   const functionExpr = 'max(2, 1, 3, 7)'

readme.md

@@ -39,12 +39,12 @@ Try out `cel-js` in your browser with the [live demo](https://stackblitz.com/git
     - [x] Dot Notation (`foo.bar`)
     - [x] Index Notation (`foo["bar"]`)
   - [x] [Macros](https://github.com/google/cel-spec/blob/master/doc/langdef.md#macros): (`has`, `size`, etc.)
-    - [ ] All (`e.all(x, p)`)
-    - [ ] Exists (`e.exists(x, p)`)
-    - [ ] Exists one (`e.exists_one(x, p)`)
-    - [ ] Filter (`e.filter(x, p)`)
+    - [x] All (`e.all(x, p)`)
+    - [x] Exists (`e.exists(x, p)`)
+    - [x] Exists one (`e.exists_one(x, p)`)
+    - [x] Filter (`e.filter(x, p)`)
     - [x] Has (`has(foo.bar)`)
-    - [ ] Map (`e.map(x, t)` and `e.map(x, p, t)`)
+    - [x] Map (`e.map(x, t)` and `e.map(x, p, t)`)
     - [x] Size (`size(foo)`)
   - [x] Unary Operators (`!true`, `-123`)
   - [x] Custom Functions (`myFunction()`)

src/cst-definitions.d.ts

@@ -161,6 +161,11 @@ export interface IdentifierDotExpressionCstNode extends CstNode {
 export type IdentifierDotExpressionCstChildren = {
   Dot: IToken[]
   Identifier: IToken[]
+  OpenParenthesis?: IToken[]
+  arg?: ExprCstNode[]
+  Comma?: IToken[]
+  args?: ExprCstNode[]
+  CloseParenthesis?: IToken[]
 }
 
 export interface IndexExpressionCstNode extends CstNode {

src/parser.ts

@@ -171,6 +171,18 @@ export class CelParser extends CstParser {
   private identifierDotExpression = this.RULE('identifierDotExpression', () => {
     this.CONSUME(Dot)
     this.CONSUME(Identifier)
+    // Optional method call with arguments (for collection macros)
+    this.OPTION(() => {
+      this.CONSUME(OpenParenthesis)
+      this.OPTION2(() => {
+        this.SUBRULE(this.expr, { LABEL: 'arg' })
+        this.MANY(() => {
+          this.CONSUME(Comma)
+          this.SUBRULE2(this.expr, { LABEL: 'args' })
+        })
+      })
+      this.CONSUME(CloseParenthesis)
+    })
   })
 
   private indexExpression = this.RULE('indexExpression', () => {

src/spec/collection-macros.spec.ts

@@ -0,0 +1,290 @@
+import { expect, describe, it } from 'vitest'
+import { CelEvaluationError, evaluate } from '..'
+
+describe('collection macros', () => {
+  const context = {
+    groups: [
+      { custom: true, name: 'group 1' },
+      { custom: false, name: 'group 2' },
+      { custom: true, name: 'group 3' },
+    ],
+    numbers: [1, 2, 3, 4, 5],
+    people: [
+      { name: 'Alice', age: 25 },
+      { name: 'Bob', age: 30 },
+      { name: 'Charlie', age: 35 },
+    ],
+    scores: { alice: 85, bob: 92, charlie: 78 },
+    nested: {
+      nested: {
+        numbers: [1, 2, 3, 4, 5],
+      },
+    },
+    map: {
+      a: 1,
+      b: 2,
+      c: 3,
+    },
+  }
+
+  describe('filter', () => {
+    it('should filter list with boolean condition', () => {
+      const expr = 'groups.filter(group, group.custom == true)'
+      const result = evaluate(expr, context)
+
+      expect(result).toStrictEqual([
+        { custom: true, name: 'group 1' },
+        { custom: true, name: 'group 3' },
+      ])
+    })
+
+    it('should filter list', () => {
+      const expr = 'numbers.filter(n, n > 3)'
+      const result = evaluate(expr, context)
+
+      expect(result).toStrictEqual([4, 5])
+    })
+
+    it('should filter maps', () => {
+      const expr = 'scores.filter(name, scores[name] > 80)'
+      const result = evaluate(expr, context)
+
+      expect(result).toStrictEqual(['alice', 'bob'])
+    })
+  })
+
+  describe('all', () => {
+    it('should return true if all items match condition', () => {
+      const expr = 'numbers.all(n, n > 0)'
+      const result = evaluate(expr, context)
+
+      expect(result).toBe(true)
+    })
+
+    it('should return false if not all items match', () => {
+      const expr = 'numbers.all(n, n > 3)'
+      const result = evaluate(expr, context)
+
+      expect(result).toBe(false)
+    })
+
+    it('should operate on lists', () => {
+      const expr = 'groups.all(group, group.custom == true)'
+      const result = evaluate(expr, context)
+
+      expect(result).toBe(false) // Not all groups have custom=true
+    })
+
+    it('should operate on maps', () => {
+      const expr = 'scores.all(name, scores[name] > 70)'
+      const result = evaluate(expr, context)
+
+      expect(result).toBe(true) // All scores are > 70
+    })
+  })
+
+  describe('exists', () => {
+    it('should return true if any item matches condition', () => {
+      const expr = 'numbers.exists(n, n > 4)'
+      const result = evaluate(expr, context)
+
+      expect(result).toBe(true)
+    })
+
+    it('should return false if no items match', () => {
+      const expr = 'numbers.exists(n, n > 10)'
+      const result = evaluate(expr, context)
+
+      expect(result).toBe(false)
+    })
+
+    it('should operate on lists', () => {
+      const expr = 'groups.exists(group, group.custom == true)'
+      const result = evaluate(expr, context)
+
+      expect(result).toBe(true) // At least one group has custom=true
+    })
+
+    it('should operate on maps', () => {
+      const expr = 'scores.exists(name, scores[name] > 80)'
+      const result = evaluate(expr, context)
+
+      expect(result).toBe(true) // At least one score is > 80
+    })
+  })
+
+  describe('exists_one', () => {
+    it('should return true if exactly one item matches', () => {
+      const expr = 'numbers.exists_one(n, n == 5)'
+      const result = evaluate(expr, context)
+
+      expect(result).toBe(true)
+    })
+
+    it('should return false if multiple items match', () => {
+      const expr = 'numbers.exists_one(n, n > 3)'
+      const result = evaluate(expr, context)
+
+      expect(result).toBe(false)
+    })
+
+    it('should return false if no items match', () => {
+      const expr = 'numbers.exists_one(n, n > 10)'
+      const result = evaluate(expr, context)
+
+      expect(result).toBe(false)
+    })
+
+    it('should operate on lists', () => {
+      const expr = 'groups.exists_one(group, group.custom == false)'
+      const result = evaluate(expr, context)
+
+      expect(result).toBe(true) // Exactly one group has custom=false
+    })
+
+    it('should operate on maps', () => {
+      const expr = 'scores.exists_one(name, scores[name] > 90)'
+      const result = evaluate(expr, context)
+
+      expect(result).toBe(true) // Exactly one score is > 90
+    })
+  })
+
+  describe('map', () => {
+    it('should transform list items (simple map)', () => {
+      const expr = 'numbers.map(n, n * 2)'
+      const result = evaluate(expr, context)
+
+      expect(result).toStrictEqual([2, 4, 6, 8, 10])
+    })
+
+    it('should filter and transform (map with predicate)', () => {
+      const expr = 'numbers.map(n, n > 3, n * 10)'
+      const result = evaluate(expr, context)
+
+      expect(result).toStrictEqual([40, 50])
+    })
+
+    it('should extract property names', () => {
+      const expr = 'people.map(person, person.name)'
+      const result = evaluate(expr, context)
+
+      expect(result).toStrictEqual(['Alice', 'Bob', 'Charlie'])
+    })
+
+    it('should operate on lists', () => {
+      const expr = 'groups.map(group, group.name)'
+      const result = evaluate(expr, context)
+
+      expect(result).toStrictEqual(['group 1', 'group 2', 'group 3'])
+    })
+
+    it('should operate on maps', () => {
+      const expr = 'scores.map(name, scores[name] * 2)'
+      const result = evaluate(expr, context)
+
+      expect(result).toStrictEqual([170, 184, 156])
+    })
+  })
+
+  describe('error handling', () => {
+    it('should throw error if collection is not a list or map', () => {
+      const contextWithString = { ...context, str: 'hello' }
+
+      expect(() => evaluate('str.map(n, n * 2)', contextWithString)).toThrow(
+        CelEvaluationError,
+      )
+    })
+
+    describe('variable name validation', () => {
+      it('should reject complex expressions as variable names', () => {
+        expect(() => evaluate('numbers.filter(x + y, true)', context)).toThrow(
+          'Variable name must be a simple identifier',
+        )
+      })
+
+      it('should reject ternary expressions as variable names', () => {
+        expect(() =>
+          evaluate('numbers.filter(x ? y : z, true)', context),
+        ).toThrow('Variable name must be a simple identifier')
+      })
+
+      it('should reject comparison expressions as variable names', () => {
+        expect(() => evaluate('numbers.filter(x > 5, true)', context)).toThrow(
+          'Variable name must be a simple identifier',
+        )
+      })
+
+      it('should reject dot notation as variable names', () => {
+        expect(() =>
+          evaluate('numbers.filter(obj.prop, true)', context),
+        ).toThrow('Variable name must be a simple identifier')
+      })
+
+      it('should reject index expressions as variable names', () => {
+        expect(() => evaluate('numbers.filter(arr[0], true)', context)).toThrow(
+          'Variable name must be a simple identifier',
+        )
+      })
+
+      it('should reject function calls as variable names', () => {
+        expect(() => evaluate('numbers.filter(func(), true)', context)).toThrow(
+          'Variable name must be a simple identifier',
+        )
+      })
+
+      it('should reject literals as variable names', () => {
+        expect(() => evaluate('numbers.filter(123, true)', context)).toThrow(
+          'Variable name must be a simple identifier',
+        )
+        expect(() =>
+          evaluate('numbers.filter("string", true)', context),
+        ).toThrow('Variable name must be a simple identifier')
+        expect(() => evaluate('numbers.filter(true, true)', context)).toThrow(
+          'Variable name must be a simple identifier',
+        )
+      })
+
+      it('should accept simple identifiers as variable names', () => {
+        // This should work fine
+        expect(() =>
+          evaluate('numbers.filter(item, item > 3)', context),
+        ).not.toThrow()
+        expect(() =>
+          evaluate('groups.map(group, group.name)', context),
+        ).not.toThrow()
+      })
+    })
+  })
+
+  describe('nested macros', () => {
+    it('should handle nested macros', () => {
+      const contextWithMap = { ...context, data: [{ a: 10, b: 5, c: 20 }] }
+      const expr = 'data.map(m, m.filter(key, m[key] > 10))'
+      const result = evaluate(expr, contextWithMap)
+
+      expect(result).toStrictEqual([['c']])
+    })
+
+    it('should handle deep nesting with multiple collections', () => {
+      const deepContext = {
+        sets: [
+          { type: 'odd', numbers: [1, 3, 5] },
+          { type: 'even', numbers: [2, 4, 6] },
+        ],
+      }
+      const expr =
+        'sets.map(set, set.numbers.filter(id, id > 3).map(id, id * 10))'
+      const result = evaluate(expr, deepContext)
+
+      expect(result).toStrictEqual([[50], [40, 60]])
+    })
+
+    it('should handle nested objects', () => {
+      const expr = 'nested.nested.numbers.map(n, n * 2)'
+      const result = evaluate(expr, context)
+
+      expect(result).toStrictEqual([2, 4, 6, 8, 10])
+    })
+  })
+})