@the-trybe/formula-engine 1.1.1 → 1.2.0

package/src/lexer.test.ts

@@ -285,4 +285,65 @@ describe('Lexer', () => {
       expect(() => lexer.tokenize()).toThrow(SyntaxError);
     });
   });
+
+  describe('Braces', () => {
+    it('should tokenize left brace', () => {
+      const lexer = new Lexer('{');
+      const tokens = lexer.tokenize();
+
+      expect(tokens[0].type).toBe(TokenType.LBRACE);
+      expect(tokens[0].value).toBe('{');
+    });
+
+    it('should tokenize right brace', () => {
+      const lexer = new Lexer('}');
+      const tokens = lexer.tokenize();
+
+      expect(tokens[0].type).toBe(TokenType.RBRACE);
+      expect(tokens[0].value).toBe('}');
+    });
+
+    it('should tokenize object literal tokens', () => {
+      const lexer = new Lexer('{ a: 1, b: 2 }');
+      const tokens = lexer.tokenize();
+
+      expect(tokens[0].type).toBe(TokenType.LBRACE);
+      expect(tokens[1].type).toBe(TokenType.IDENTIFIER);
+      expect(tokens[1].value).toBe('a');
+      expect(tokens[2].type).toBe(TokenType.COLON);
+      expect(tokens[3].type).toBe(TokenType.NUMBER);
+      expect(tokens[3].value).toBe('1');
+      expect(tokens[4].type).toBe(TokenType.COMMA);
+      expect(tokens[5].type).toBe(TokenType.IDENTIFIER);
+      expect(tokens[5].value).toBe('b');
+      expect(tokens[6].type).toBe(TokenType.COLON);
+      expect(tokens[7].type).toBe(TokenType.NUMBER);
+      expect(tokens[7].value).toBe('2');
+      expect(tokens[8].type).toBe(TokenType.RBRACE);
+      expect(tokens[9].type).toBe(TokenType.EOF);
+    });
+
+    it('should tokenize nested braces', () => {
+      const lexer = new Lexer('{ a: { b: 1 } }');
+      const tokens = lexer.tokenize();
+
+      expect(tokens[0].type).toBe(TokenType.LBRACE);
+      expect(tokens[3].type).toBe(TokenType.LBRACE);
+      expect(tokens[7].type).toBe(TokenType.RBRACE);
+      expect(tokens[8].type).toBe(TokenType.RBRACE);
+    });
+
+    it('should tokenize braces with variable values', () => {
+      const lexer = new Lexer('{ type: @client.type }');
+      const tokens = lexer.tokenize();
+
+      expect(tokens[0].type).toBe(TokenType.LBRACE);
+      expect(tokens[1].type).toBe(TokenType.IDENTIFIER);
+      expect(tokens[2].type).toBe(TokenType.COLON);
+      expect(tokens[3].type).toBe(TokenType.CONTEXT_VAR);
+      expect(tokens[4].type).toBe(TokenType.DOT);
+      expect(tokens[5].type).toBe(TokenType.IDENTIFIER);
+      expect(tokens[6].type).toBe(TokenType.RBRACE);
+    });
+  });
 });

package/src/lexer.ts

@@ -110,6 +110,12 @@ export class Lexer {
       case ']':
         this.addToken(TokenType.RBRACKET, ']');
         break;
+      case '{':
+        this.addToken(TokenType.LBRACE, '{');
+        break;
+      case '}':
+        this.addToken(TokenType.RBRACE, '}');
+        break;
       case ',':
         this.addToken(TokenType.COMMA, ',');
         break;

package/src/parser.test.ts

@@ -346,4 +346,113 @@ describe('Parser', () => {
       expect(() => parser.parse('$a ? $b')).toThrow(UnexpectedTokenError);
     });
   });
+
+  describe('Object Literals', () => {
+    it('should parse empty object literal', () => {
+      const ast = parser.parse('{}');
+
+      expect(ast.type).toBe('ObjectLiteral');
+      expect((ast as any).properties).toHaveLength(0);
+    });
+
+    it('should parse single-property object literal', () => {
+      const ast = parser.parse('{ name: "test" }');
+
+      expect(ast.type).toBe('ObjectLiteral');
+      expect((ast as any).properties).toHaveLength(1);
+      expect((ast as any).properties[0].key).toBe('name');
+      expect((ast as any).properties[0].value.type).toBe('StringLiteral');
+      expect((ast as any).properties[0].value.value).toBe('test');
+    });
+
+    it('should parse multi-property object literal', () => {
+      const ast = parser.parse('{ a: 1, b: 2, c: 3 }');
+
+      expect(ast.type).toBe('ObjectLiteral');
+      expect((ast as any).properties).toHaveLength(3);
+      expect((ast as any).properties[0].key).toBe('a');
+      expect((ast as any).properties[1].key).toBe('b');
+      expect((ast as any).properties[2].key).toBe('c');
+    });
+
+    it('should parse object literal with expression values', () => {
+      const ast = parser.parse('{ total: $a + $b }');
+
+      expect(ast.type).toBe('ObjectLiteral');
+      expect((ast as any).properties[0].key).toBe('total');
+      expect((ast as any).properties[0].value.type).toBe('BinaryOperation');
+      expect((ast as any).properties[0].value.operator).toBe('+');
+    });
+
+    it('should parse object literal with context variable values', () => {
+      const ast = parser.parse('{ zone: @client.zone }');
+
+      expect(ast.type).toBe('ObjectLiteral');
+      expect((ast as any).properties[0].key).toBe('zone');
+      expect((ast as any).properties[0].value.type).toBe('MemberAccess');
+    });
+
+    it('should parse object literal with variable values', () => {
+      const ast = parser.parse('{ price: $unitPrice, qty: $quantity }');
+
+      expect(ast.type).toBe('ObjectLiteral');
+      expect((ast as any).properties).toHaveLength(2);
+      expect((ast as any).properties[0].value.type).toBe('VariableReference');
+      expect((ast as any).properties[0].value.name).toBe('unitPrice');
+      expect((ast as any).properties[1].value.type).toBe('VariableReference');
+      expect((ast as any).properties[1].value.name).toBe('quantity');
+    });
+
+    it('should parse nested object literals', () => {
+      const ast = parser.parse('{ inner: { x: 1 } }');
+
+      expect(ast.type).toBe('ObjectLiteral');
+      expect((ast as any).properties[0].key).toBe('inner');
+      expect((ast as any).properties[0].value.type).toBe('ObjectLiteral');
+      expect((ast as any).properties[0].value.properties[0].key).toBe('x');
+    });
+
+    it('should parse object literal as function argument', () => {
+      const ast = parser.parse('LOOKUP($t, { a: 1 }, "r")');
+
+      expect(ast.type).toBe('FunctionCall');
+      expect((ast as any).name).toBe('LOOKUP');
+      expect((ast as any).arguments).toHaveLength(3);
+      expect((ast as any).arguments[1].type).toBe('ObjectLiteral');
+      expect((ast as any).arguments[1].properties[0].key).toBe('a');
+    });
+
+    it('should parse object literal with boolean and null values', () => {
+      const ast = parser.parse('{ active: true, deleted: false, data: null }');
+
+      expect(ast.type).toBe('ObjectLiteral');
+      expect((ast as any).properties).toHaveLength(3);
+      expect((ast as any).properties[0].value.type).toBe('BooleanLiteral');
+      expect((ast as any).properties[1].value.type).toBe('BooleanLiteral');
+      expect((ast as any).properties[2].value.type).toBe('NullLiteral');
+    });
+
+    it('should parse object literal with array value', () => {
+      const ast = parser.parse('{ items: [1, 2, 3] }');
+
+      expect(ast.type).toBe('ObjectLiteral');
+      expect((ast as any).properties[0].value.type).toBe('ArrayLiteral');
+    });
+
+    it('should throw on missing colon in object literal', () => {
+      expect(() => parser.parse('{ a 1 }')).toThrow(UnexpectedTokenError);
+    });
+
+    it('should throw on non-identifier key', () => {
+      expect(() => parser.parse('{ 123: 1 }')).toThrow(UnexpectedTokenError);
+    });
+
+    it('should throw on string key', () => {
+      expect(() => parser.parse('{ "key": 1 }')).toThrow(UnexpectedTokenError);
+    });
+
+    it('should throw on unclosed brace', () => {
+      expect(() => parser.parse('{ a: 1')).toThrow(UnexpectedTokenError);
+    });
+  });
 });

package/src/parser.ts

@@ -75,13 +75,15 @@ export class Parser {
         return this.parseGroupedExpression();
       case TokenType.LBRACKET:
         return this.parseArrayLiteral();
+      case TokenType.LBRACE:
+        return this.parseObjectLiteral();
       case TokenType.MINUS:
       case TokenType.NOT:
         return this.parseUnaryExpression();
       default:
         throw new UnexpectedTokenError(
           String(token.value),
-          ['number', 'string', 'boolean', 'null', 'variable', 'identifier', '(', '[', '-', '!'],
+          ['number', 'string', 'boolean', 'null', 'variable', 'identifier', '(', '[', '{', '-', '!'],
           token.position
         );
     }
@@ -266,6 +268,43 @@ export class Parser {
     };
   }
 
+  private parseObjectLiteral(): ASTNode {
+    this.advance(); // consume '{'
+    const properties: { key: string; value: ASTNode }[] = [];
+
+    if (this.peek().type !== TokenType.RBRACE) {
+      do {
+        if (this.peek().type === TokenType.COMMA) {
+          this.advance();
+        }
+        // Key must be an identifier
+        const keyToken = this.peek();
+        if (keyToken.type !== TokenType.IDENTIFIER) {
+          throw new UnexpectedTokenError(
+            String(keyToken.value),
+            ['identifier (property name)'],
+            keyToken.position
+          );
+        }
+        const key = String(this.advance().value);
+
+        // Expect colon
+        this.expect(TokenType.COLON, ':');
+
+        // Value is any expression
+        const value = this.parseExpression(PRECEDENCE.LOWEST);
+        properties.push({ key, value });
+      } while (this.peek().type === TokenType.COMMA);
+    }
+
+    this.expect(TokenType.RBRACE, '}');
+
+    return {
+      type: 'ObjectLiteral',
+      properties,
+    };
+  }
+
   private parseUnaryExpression(): ASTNode {
     const token = this.advance();
     const operator = this.getOperatorSymbol(token.type);

package/src/types.ts

@@ -143,6 +143,16 @@ export interface ArrayLiteral {
   elements: ASTNode[];
 }
 
+export interface ObjectLiteralProperty {
+  key: string;
+  value: ASTNode;
+}
+
+export interface ObjectLiteral {
+  type: 'ObjectLiteral';
+  properties: ObjectLiteralProperty[];
+}
+
 export interface VariableReference {
   type: 'VariableReference';
   prefix: '$' | '@';
@@ -194,6 +204,7 @@ export type ASTNode =
   | BooleanLiteral
   | NullLiteral
   | ArrayLiteral
+  | ObjectLiteral
   | VariableReference
   | BinaryOperation
   | UnaryOperation
@@ -342,6 +353,8 @@ export enum TokenType {
   RPAREN = 'RPAREN',
   LBRACKET = 'LBRACKET',
   RBRACKET = 'RBRACKET',
+  LBRACE = 'LBRACE',
+  RBRACE = 'RBRACE',
   COMMA = 'COMMA',
   DOT = 'DOT',
   QUESTION = 'QUESTION',

package/.claude/settings.local.json

@@ -1,6 +0,0 @@
-{
-  "enabledMcpjsonServers": [
-    "trigger"
-  ],
-  "enableAllProjectMcpServers": true
-}