feat: ✨ map support

.github/pull_request_template.md

@@ -10,4 +10,5 @@
 
 - [ ] I have performed a self-review of my code
 - [ ] I have added tests (if possible)
-
+- [ ] I have updated the readme (if necessary)
+- [ ] I have updated the demo (if necessary)

demo/demo.ts

@@ -33,9 +33,14 @@ import { evaluate, parse } from 'cel-js'
   const arrayExpr = '[1, 2]'
   console.log(`${arrayExpr} => ${evaluate(arrayExpr)}`) // => [1, 2]
 
+  // Map expressions
+  // TODO - bump version to 0.1.5 and uncomment
+  // const mapExpr = '{"a": 1, "b": {"c": 2} }'
+  // console.log(`${mapExpr} => ${evaluate(mapExpr)}`) // => { a: 1, b: { c: 2 } }
+
   // Macro expressions
   const macroExpr = 'size([1, 2])'
-  console.log(`${arrayExpr} => ${evaluate(macroExpr)}`) // => 2
+  console.log(`${macroExpr} => ${evaluate(macroExpr)}`) // => 2
 }
 
 // Parse an expression, useful for validation purposes before persisting

demo/package.json

@@ -4,7 +4,7 @@
   "description": "A simple usage of the CEL library",
   "type": "module",
   "dependencies": {
-    "cel-js": "0.1.2"
+    "cel-js": "0.1.4"
   },
   "devDependencies": {
     "tsx": "4.7.0"

package.json

@@ -35,11 +35,13 @@
     "release": "release-it"
   },
   "dependencies": {
-    "chevrotain": "11.0.3"
+    "chevrotain": "11.0.3",
+    "ramda": "0.29.1"
   },
   "devDependencies": {
     "@commitlint/cli": "18.4.3",
     "@commitlint/config-conventional": "18.4.3",
+    "@types/ramda": "0.29.11",
     "@types/lodash.get": "4.4.9",
     "@types/node": "20.9.0",
     "@typescript-eslint/eslint-plugin": "6.10.0",

readme.md

@@ -20,7 +20,7 @@ Try out `cel-js` in your browser with the [live demo](https://stackblitz.com/git
     - [x] string
     - [ ] bytes
     - [x] list
-    - [ ] map
+    - [x] map
     - [x] null 
   - [x] Conditional Operators
     - [ ] Ternary (`condition ? true : false`)

src/cst-definitions.d.ts

@@ -99,6 +99,31 @@ export type ListExpressionCstChildren = {
   Index?: IndexExpressionCstNode[];
 };
 
+export interface MapExpressionCstNode extends CstNode {
+  name: "mapExpression";
+  children: MapExpressionCstChildren;
+}
+
+export type MapExpressionCstChildren = {
+  OpenCurlyBracket: IToken[];
+  keyValues?: MapKeyValuesCstNode[];
+  CloseCurlyBracket: IToken[];
+  identifierDotExpression?: IdentifierDotExpressionCstNode[];
+  identifierIndexExpression?: IndexExpressionCstNode[];
+};
+
+export interface MapKeyValuesCstNode extends CstNode {
+  name: "mapKeyValues";
+  children: MapKeyValuesCstChildren;
+}
+
+export type MapKeyValuesCstChildren = {
+  key: ExprCstNode[];
+  Colon: IToken[];
+  value: ExprCstNode[];
+  Comma?: IToken[];
+};
+
 export interface MacrosExpressionCstNode extends CstNode {
   name: "macrosExpression";
   children: MacrosExpressionCstChildren;
@@ -157,6 +182,7 @@ export type AtomicExpressionCstChildren = {
   Integer?: IToken[];
   ReservedIdentifiers?: IToken[];
   listExpression?: ListExpressionCstNode[];
+  mapExpression?: MapExpressionCstNode[];
   macrosExpression?: MacrosExpressionCstNode[];
   identifierExpression?: IdentifierExpressionCstNode[];
 };
@@ -171,6 +197,8 @@ export interface ICstNodeVisitor<IN, OUT> extends ICstVisitor<IN, OUT> {
   unaryExpression(children: UnaryExpressionCstChildren, param?: IN): OUT;
   parenthesisExpression(children: ParenthesisExpressionCstChildren, param?: IN): OUT;
   listExpression(children: ListExpressionCstChildren, param?: IN): OUT;
+  mapExpression(children: MapExpressionCstChildren, param?: IN): OUT;
+  mapKeyValues(children: MapKeyValuesCstChildren, param?: IN): OUT;
   macrosExpression(children: MacrosExpressionCstChildren, param?: IN): OUT;
   identifierExpression(children: IdentifierExpressionCstChildren, param?: IN): OUT;
   identifierDotExpression(children: IdentifierDotExpressionCstChildren, param?: IN): OUT;

src/helper.ts

@@ -22,6 +22,7 @@ import {
   IdentifierDotExpressionCstNode,
   IndexExpressionCstNode,
 } from './cst-definitions.js'
+import { equals } from 'ramda'
 
 export enum CelType {
   int = 'int',
@@ -56,6 +57,9 @@ const isArray = (value: unknown): value is unknown[] =>
 const isBoolean = (value: unknown): value is boolean =>
   getCelType(value) === CelType.bool
 
+const isMap = (value: unknown): value is Record<string, unknown> =>
+  getCelType(value) === CelType.map
+
 export const getCelType = (value: unknown): CelType => {
   if (value === null) {
     return CelType.null
@@ -194,6 +198,16 @@ const logicalOrOperation = (left: unknown, right: unknown) => {
   throw new CelTypeError(Operations.logicalOr, left, right)
 }
 
+const comparisonInOperation = (left: unknown, right: unknown) => {
+  if (isArray(right)) {
+    return right.includes(left)
+  }
+  if (isMap(right)) {
+    return Object.keys(right).includes(left as string)
+  }
+  throw new CelTypeError(Operations.in, left, right)
+}
+
 const comparisonOperation = (
   operation: Operations,
   left: unknown,
@@ -216,15 +230,15 @@ const comparisonOperation = (
   }
 
   if (operation === Operations.equals) {
-    return left === right
+    return equals(left, right)
   }
 
   if (operation === Operations.notEquals) {
-    return left !== right
+    return !equals(left, right)
   }
 
-  if (operation === Operations.in && isArray(right)) {
-    return right.includes(left)
+  if (operation === Operations.in) {
+    return comparisonInOperation(left, right)
   }
 
   throw new CelTypeError(operation, left, right)
@@ -301,3 +315,15 @@ export const getPosition = (
 
   return ctx.children.OpenBracket[0].startOffset
 }
+
+export const size = (arr: unknown) => {
+  if (isString(arr) || isArray(arr)) {
+    return arr.length
+  }
+
+  if (isMap(arr)) {
+    return Object.keys(arr).length
+  }
+
+  throw new CelEvaluationError(`invalid_argument: ${arr}`)
+}

src/parser.ts

@@ -21,6 +21,9 @@ import {
   OpenBracket,
   Comma,
   MacrosIdentifier,
+  OpenCurlyBracket,
+  CloseCurlyBracket,
+  Colon,
 } from './tokens.js'
 
 export class CelParser extends CstParser {
@@ -101,6 +104,34 @@ export class CelParser extends CstParser {
     })
   })
 
+  private mapExpression = this.RULE('mapExpression', () => {
+    this.CONSUME(OpenCurlyBracket)
+    this.MANY(() => {
+      this.SUBRULE(this.mapKeyValues, { LABEL: 'keyValues' })
+    })
+    this.CONSUME(CloseCurlyBracket)
+    this.MANY2(() => {
+      this.OR([
+        { ALT: () => this.SUBRULE(this.identifierDotExpression) },
+        {
+          ALT: () =>
+            this.SUBRULE(this.indexExpression, {
+              LABEL: 'identifierIndexExpression',
+            }),
+        },
+      ])
+    })
+  })
+
+  private mapKeyValues = this.RULE('mapKeyValues', () => {
+    this.SUBRULE(this.expr, { LABEL: 'key' })
+    this.CONSUME(Colon)
+    this.SUBRULE2(this.expr, { LABEL: 'value' })
+    this.OPTION(() => {
+      this.CONSUME(Comma)
+    })
+  })
+
   private macrosExpression = this.RULE('macrosExpression', () => {
     this.CONSUME(MacrosIdentifier)
     this.CONSUME(OpenParenthesis)
@@ -115,24 +146,26 @@ export class CelParser extends CstParser {
     this.MANY(() => {
       this.OR([
         { ALT: () => this.SUBRULE(this.identifierDotExpression) },
-        { ALT: () => this.SUBRULE(this.indexExpression, {LABEL: 'identifierIndexExpression'}) },
+        {
+          ALT: () =>
+            this.SUBRULE(this.indexExpression, {
+              LABEL: 'identifierIndexExpression',
+            }),
+        },
       ])
-    })  
+    })
   })
 
   private identifierDotExpression = this.RULE('identifierDotExpression', () => {
     this.CONSUME(Dot)
     this.CONSUME(Identifier)
   })
 
-  private indexExpression = this.RULE(
-    'indexExpression',
-    () => {
-      this.CONSUME(OpenBracket)
-      this.SUBRULE(this.expr)
-      this.CONSUME(CloseBracket)
-    }
-  )
+  private indexExpression = this.RULE('indexExpression', () => {
+    this.CONSUME(OpenBracket)
+    this.SUBRULE(this.expr)
+    this.CONSUME(CloseBracket)
+  })
 
   private atomicExpression = this.RULE('atomicExpression', () => {
     this.OR([
@@ -144,6 +177,7 @@ export class CelParser extends CstParser {
       { ALT: () => this.CONSUME(Integer) },
       { ALT: () => this.CONSUME(ReservedIdentifiers) },
       { ALT: () => this.SUBRULE(this.listExpression) },
+      { ALT: () => this.SUBRULE(this.mapExpression) },
       { ALT: () => this.SUBRULE(this.macrosExpression) },
       { ALT: () => this.SUBRULE(this.identifierExpression) },
     ])

src/spec/macros.spec.ts

@@ -31,6 +31,32 @@ describe('lists expressions', () => {
       })
     })
 
+    describe('map', () => {
+      it('should return 0 for empty map', () => {
+        const expr = 'size({})'
+
+        const result = evaluate(expr)
+
+        expect(result).toBe(0)
+      })
+
+      it('should return 1 for one element map', () => {
+        const expr = 'size({"a": 1})'
+
+        const result = evaluate(expr)
+
+        expect(result).toBe(1)
+      })
+
+      it('should return 3 for three element map', () => {
+        const expr = 'size({"a": 1, "b": 2, "c": 3})'
+
+        const result = evaluate(expr)
+
+        expect(result).toBe(3)
+      })
+    })
+
     describe('string', () => {
       it('should return 0 for empty string', () => {
         const expr = 'size("")'