feat: Implement ternary operator

This commit introduces the ternary operator (? :) to the expression language.

The following changes were made:
- Added TernaryNode to AST.type.ts
- Added TOK_QUESTION to Lexer.ts and Lexer.type.ts
- Updated Parser.ts to handle the ternary operator
- Updated TreeInterpreter.ts to evaluate ternary expressions
- Updated compliance tests (points to `feature/ternary-operator` branch for now)

<!-- ps-id: 23d6602d-719c-495d-8421-97a050351f6f -->

Author: cawalch

.npmrc renamed to .nvmrc

@@ -78,6 +78,13 @@ export interface VariableNode {
   readonly name: string;
 }
 
+export interface TernaryNode {
+  readonly type: 'Ternary';
+  readonly condition: ExpressionNode;
+  readonly trueExpr: ExpressionNode;
+  readonly falseExpr: ExpressionNode;
+}
+
 type BinaryExpressionType =
   | 'AndExpression'
   | 'IndexExpression'
@@ -139,6 +146,7 @@ export type ExpressionNode =
   | FunctionNode
   | LetExpressionNode
   | BindingNode
-  | VariableNode;
+  | VariableNode
+  | TernaryNode;
 
 export type ExpressionReference = { expref: true } & ExpressionNode;

src/AST.type.ts

@@ -16,6 +16,7 @@ export const basicTokens: Record<string, Token> = {
   '}': Token.TOK_RBRACE,
   '+': Token.TOK_PLUS,
   '%': Token.TOK_MODULO,
+  '?': Token.TOK_QUESTION,
   '\u2212': Token.TOK_MINUS,
   '\u00d7': Token.TOK_MULTIPLY,
   '\u00f7': Token.TOK_DIVIDE,

src/Lexer.ts

@@ -39,6 +39,7 @@ export enum Token {
   TOK_LBRACKET = 'Lbracket',
   TOK_LPAREN = 'Lparen',
   TOK_LITERAL = 'Literal',
+  TOK_QUESTION = 'Question',
 }
 
 export type LexerTokenValue = JSONValue;

src/Lexer.type.ts

@@ -20,6 +20,7 @@ import { LexerToken, Token } from './Lexer.type';
 import { Options } from './Parser.type';
 
 const bindingPower: Record<string, number> = {
+  [Token.TOK_QUESTION]: 4,
   [Token.TOK_EOF]: 0,
   [Token.TOK_VARIABLE]: 0,
   [Token.TOK_UNQUOTEDIDENTIFIER]: 0,
@@ -202,6 +203,17 @@ class TokenParser {
 
   led(tokenName: string, left: ExpressionNode): ExpressionNode {
     switch (tokenName) {
+      case Token.TOK_QUESTION: {
+        const trueExpr = this.expression(0);
+        this.match(Token.TOK_COLON);
+        const falseExpr = this.expression(0);
+        return {
+          type: 'Ternary',
+          condition: left,
+          trueExpr,
+          falseExpr,
+        };
+      }
       case Token.TOK_DOT: {
         const rbp = bindingPower.Dot;
         if (this.lookahead(0) !== Token.TOK_STAR) {

src/Parser.ts

@@ -33,13 +33,20 @@ export class TreeInterpreter {
 
   visit(node: ExpressionNode, value: JSONValue | ExpressionNode): JSONValue | ExpressionNode | ExpressionReference {
     switch (node.type) {
+      case 'Ternary': {
+        const condition = this.visit(node.condition, value);
+        if (!isFalse(condition)) {
+          return this.visit(node.trueExpr, value);
+        }
+        return this.visit(node.falseExpr, value);
+      }
       case 'Field':
         const identifier = node.name;
-        let result: JSONValue = null;
-        if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
-          result = (value as JSONObject)[identifier] ?? null;
+        if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+          return null;
         }
-        return result;
+        // return the value of the field
+        return (value as JSONObject)[identifier] ?? null;
       case 'LetExpression': {
         const { bindings, expression } = node;
         let scope = {};

src/TreeInterpreter.ts

@@ -40,33 +40,34 @@ export const strictDeepEqual = (first: unknown, second: unknown): boolean => {
 };
 
 export const isFalse = (obj: unknown): boolean => {
+  // falsey values
+  if (obj === null || obj === undefined || obj === false) {
+    return true;
+  }
+  if (typeof obj === 'string') {
+    return obj === '';
+  }
   if (typeof obj === 'object') {
-    if (obj === null) {
-      return true;
-    }
     if (Array.isArray(obj)) {
       return obj.length === 0;
     }
-    // eslint-disable-next-line @typescript-eslint/naming-convention
-    for (const _key in obj) {
-      return false;
+    if (obj === null) {
+      return true;
     }
-    return true;
+    // check if object is empty
+    return Object.keys(obj).length === 0;
   }
-  return !(typeof obj === 'number' || obj);
+  return false;
 };
 
 export const isAlpha = (ch: string): boolean => {
-  // tslint:disable-next-line: strict-comparisons
   return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ch === '_';
 };
 
 export const isNum = (ch: string): boolean => {
-  // tslint:disable-next-line: strict-comparisons
   return (ch >= '0' && ch <= '9') || ch === '-';
 };
 export const isAlphaNum = (ch: string): boolean => {
-  // tslint:disable-next-line: strict-comparisons
   return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9') || ch === '_';
 };
 

src/utils/index.ts

@@ -0,0 +1,99 @@
+import { search } from '../src';
+import { describe, it, expect } from 'vitest';
+
+describe('JMESPath Ternary Operations', () => {
+  const data = {
+    true: true,
+    false: false,
+    foo: 'foo',
+    bar: 'bar',
+    baz: 'baz',
+    qux: 'qux',
+    quux: 'quux',
+    two: 2,
+    fourty: 40,
+  };
+
+  describe('Basic Ternary Operations', () => {
+    it('should return foo when condition is true', () => {
+      expect(search(data, 'true ? foo : bar')).toBe('foo');
+    });
+
+    it('should return bar when condition is false', () => {
+      expect(search(data, 'false ? foo : bar')).toBe('bar');
+    });
+
+    it('should return bar when condition is null', () => {
+      expect(search(data, '`null` ? foo : bar')).toBe('bar');
+    });
+
+    it('should return bar when condition is empty array', () => {
+      expect(search(data, '`[]` ? foo : bar')).toBe('bar');
+    });
+
+    it('should return bar when condition is not an empty array', () => {
+      expect(search(data, '`[1]` ? foo : bar')).toBe('foo');
+    });
+
+    it('should return bar when condition is empty object', () => {
+      expect(search(data, '`{}` ? foo : bar')).toBe('bar');
+    });
+
+    it('should return bar when condition is empty string', () => {
+      expect(search(data, "'' ? foo : bar")).toBe('bar');
+    });
+  });
+
+  describe('Chained Ternary Operations', () => {
+    it('should handle chained ternary operations', () => {
+      expect(search(data, 'foo ? bar ? baz : qux : quux')).toBe('baz');
+    });
+  });
+
+  describe('Ternary Operations with Precedence', () => {
+    it('should handle precedence with pipes', () => {
+      expect(search(data, 'false ? foo | bar | @ : baz')).toBe('baz');
+    });
+
+    it('should handle precedence with arithmetic', () => {
+      expect(search(data, 'foo ? fourty + two : `false`')).toBe(42);
+    });
+  });
+
+  describe('Nested Ternary Operations', () => {
+    it('should handle left-nested ternary operations', () => {
+      expect(search(data, 'true ? (true ? foo : bar) : baz')).toBe('foo');
+      expect(search(data, 'true ? (false ? foo : bar) : baz')).toBe('bar');
+      expect(search(data, 'false ? (true ? foo : bar) : baz')).toBe('baz');
+    });
+
+    it('should handle right-nested ternary operations', () => {
+      expect(search(data, 'true ? foo : (true ? bar : baz)')).toBe('foo');
+      expect(search(data, 'false ? foo : (true ? bar : baz)')).toBe('bar');
+      expect(search(data, 'false ? foo : (false ? bar : baz)')).toBe('baz');
+    });
+
+    it('should handle multiple nested ternary operations', () => {
+      expect(search(data, 'true ? (true ? (true ? foo : bar) : baz) : quux')).toBe('foo');
+      expect(search(data, 'true ? (true ? (false ? foo : bar) : baz) : quux')).toBe('bar');
+      expect(search(data, 'true ? (false ? (true ? foo : bar) : baz) : quux')).toBe('baz');
+      expect(search(data, 'false ? (true ? (true ? foo : bar) : baz) : quux')).toBe('quux');
+    });
+
+    it('should handle mixed nested ternary operations with literals', () => {
+      expect(search(data, 'true ? (`null` ? foo : bar) : baz')).toBe('bar');
+      expect(search(data, 'true ? (`[]` ? foo : bar) : baz')).toBe('bar');
+      expect(search(data, 'true ? (`{}` ? foo : bar) : baz')).toBe('bar');
+      expect(search(data, "true ? (''  ? foo : bar) : baz")).toBe('bar');
+    });
+
+    it('should handle nested ternary operations with arithmetic', () => {
+      const testData = {
+        ...data,
+        threshold: 40,
+      };
+      expect(search(testData, 'true ? (fourty + two > threshold ? foo : bar) : baz')).toBe('foo');
+      expect(search(testData, 'true ? (fourty + two < threshold ? foo : bar) : baz')).toBe('bar');
+    });
+  });
+});

test/compliance

@@ -23,7 +23,6 @@
     "sourceMap": true,
     "strict": true,
     "strictNullChecks": true,
-    "suppressImplicitAnyIndexErrors": true,
     "typeRoots": ["node_modules/@types"]
   },
   "exclude": ["node_modules", "dist", "test"],