feat: add support for json path syntax

.gitignore

@@ -137,4 +137,6 @@ build/
 .stryker-tmp
 
 Mac
-.DS_Store
+.DS_Store
+
+test/test_engine.ts

.nvmrc

@@ -1 +1 @@
-18.19.0
+18.20.3

readme.md

@@ -216,6 +216,12 @@ If we use this rich path`~r a.b.c` then it automatically handles following varia
 - `{"a": [{ "b": [{"c": 2}]}]}`
   Refer this [example](test/scenarios/paths/rich_path.jt) for more details.
 
+#### Json Paths
+We support some features of [JSON Path](https://goessner.net/articles/JsonPath/index.html#) syntax using path option (`~j`).
+Note: This is an experimental feature and may not support all the features of JSON Paths. 
+
+Refer this [example](test/scenarios/paths/json_path.jt) for more details.
+
 #### Simple selectors
 
 ```js
@@ -333,6 +339,8 @@ We can override the default path option using tags.
 ~s a.b.c
 // Use ~r to treat a.b.c as rich path
 ~r a.b.c
+// Use ~j for using json paths
+~j items[?(@.a>1)]
 ```
 
 **Note:** Rich paths are slower compare to the simple paths.

src/constants.ts

@@ -1,6 +1,9 @@
+import { SyntaxType } from './types';
+
 export const VARS_PREFIX = '___';
 export const DATA_PARAM_KEY = '___d';
 export const BINDINGS_PARAM_KEY = '___b';
 export const BINDINGS_CONTEXT_KEY = '___b.context.';
 export const RESULT_KEY = '___r';
 export const FUNCTION_RESULT_KEY = '___f';
+export const EMPTY_EXPR = { type: SyntaxType.EMPTY };

src/engine.ts

@@ -2,8 +2,8 @@ import { BINDINGS_PARAM_KEY, DATA_PARAM_KEY } from './constants';
 import { JsonTemplateLexer } from './lexer';
 import { JsonTemplateParser } from './parser';
 import { JsonTemplateTranslator } from './translator';
-import { EngineOptions, Expression } from './types';
-import { CommonUtils } from './utils';
+import { EngineOptions, Expression, FlatMappingAST, FlatMappingPaths } from './types';
+import { CreateAsyncFunction, convertToObjectMapping } from './utils';
 
 export class JsonTemplateEngine {
   private readonly fn: Function;
@@ -12,17 +12,6 @@ export class JsonTemplateEngine {
     this.fn = fn;
   }
 
-  static create(templateOrExpr: string | Expression, options?: EngineOptions): JsonTemplateEngine {
-    return new JsonTemplateEngine(this.compileAsAsync(templateOrExpr, options));
-  }
-
-  static createAsSync(
-    templateOrExpr: string | Expression,
-    options?: EngineOptions,
-  ): JsonTemplateEngine {
-    return new JsonTemplateEngine(this.compileAsSync(templateOrExpr, options));
-  }
-
   private static compileAsSync(
     templateOrExpr: string | Expression,
     options?: EngineOptions,
@@ -32,29 +21,16 @@ export class JsonTemplateEngine {
   }
 
   private static compileAsAsync(
-    templateOrExpr: string | Expression,
+    templateOrExpr: string | Expression | FlatMappingPaths[],
     options?: EngineOptions,
   ): Function {
-    return CommonUtils.CreateAsyncFunction(
+    return CreateAsyncFunction(
       DATA_PARAM_KEY,
       BINDINGS_PARAM_KEY,
       this.translate(templateOrExpr, options),
     );
   }
 
-  static parse(template: string, options?: EngineOptions): Expression {
-    const lexer = new JsonTemplateLexer(template);
-    const parser = new JsonTemplateParser(lexer, options);
-    return parser.parse();
-  }
-
-  static translate(templateOrExpr: string | Expression, options?: EngineOptions): string {
-    if (typeof templateOrExpr === 'string') {
-      return this.translateTemplate(templateOrExpr, options);
-    }
-    return this.translateExpression(templateOrExpr);
-  }
-
   private static translateTemplate(template: string, options?: EngineOptions): string {
     return this.translateExpression(this.parse(template, options));
   }
@@ -64,7 +40,48 @@ export class JsonTemplateEngine {
     return translator.translate();
   }
 
-  evaluate(data: any, bindings: Record<string, any> = {}): any {
+  static parseMappingPaths(mappings: FlatMappingPaths[]): FlatMappingAST[] {
+    return mappings.map((mapping) => ({
+      input: JsonTemplateEngine.parse(mapping.input).statements[0],
+      output: JsonTemplateEngine.parse(mapping.output).statements[0],
+    }));
+  }
+
+  static create(
+    templateOrExpr: string | Expression | FlatMappingPaths[],
+    options?: EngineOptions,
+  ): JsonTemplateEngine {
+    return new JsonTemplateEngine(this.compileAsAsync(templateOrExpr, options));
+  }
+
+  static createAsSync(
+    templateOrExpr: string | Expression,
+    options?: EngineOptions,
+  ): JsonTemplateEngine {
+    return new JsonTemplateEngine(this.compileAsSync(templateOrExpr, options));
+  }
+
+  static parse(template: string, options?: EngineOptions): Expression {
+    const lexer = new JsonTemplateLexer(template);
+    const parser = new JsonTemplateParser(lexer, options);
+    return parser.parse();
+  }
+
+  static translate(
+    template: string | Expression | FlatMappingPaths[],
+    options?: EngineOptions,
+  ): string {
+    if (typeof template === 'string') {
+      return this.translateTemplate(template, options);
+    }
+    let templateExpr = template as Expression;
+    if (Array.isArray(template)) {
+      templateExpr = convertToObjectMapping(this.parseMappingPaths(template));
+    }
+    return this.translateExpression(templateExpr);
+  }
+
+  evaluate(data: unknown, bindings: Record<string, unknown> = {}): unknown {
     return this.fn(data ?? {}, bindings);
   }
 }

src/lexer.ts

@@ -1,4 +1,4 @@
-import { BINDINGS_PARAM_KEY, VARS_PREFIX } from './constants';
+import { VARS_PREFIX } from './constants';
 import { JsonTemplateLexerError } from './errors';
 import { Keyword, Token, TokenType } from './types';
 
@@ -81,12 +81,16 @@ export class JsonTemplateLexer {
     return this.match('~r');
   }
 
+  matchJsonPath(): boolean {
+    return this.match('~j');
+  }
+
   matchPathType(): boolean {
-    return this.matchRichPath() || this.matchSimplePath();
+    return this.matchRichPath() || this.matchJsonPath() || this.matchSimplePath();
   }
 
   matchPath(): boolean {
-    return this.matchPathSelector() || this.matchID();
+    return this.matchPathType() || this.matchPathSelector() || this.matchID();
   }
 
   matchSpread(): boolean {
@@ -113,7 +117,7 @@ export class JsonTemplateLexer {
     const token = this.lookahead();
     if (token.type === TokenType.PUNCT) {
       const { value } = token;
-      return value === '.' || value === '..' || value === '^';
+      return value === '.' || value === '..' || value === '^' || value === '$' || value === '@';
     }
 
     return false;
@@ -145,8 +149,24 @@ export class JsonTemplateLexer {
     return token.type === TokenType.KEYWORD && token.value === val;
   }
 
+  matchContains(): boolean {
+    return this.matchKeywordValue(Keyword.CONTAINS);
+  }
+
+  matchEmpty(): boolean {
+    return this.matchKeywordValue(Keyword.EMPTY);
+  }
+
+  matchSize(): boolean {
+    return this.matchKeywordValue(Keyword.SIZE);
+  }
+
+  matchSubsetOf(): boolean {
+    return this.matchKeywordValue(Keyword.SUBSETOF);
+  }
+
   matchIN(): boolean {
-    return this.matchKeywordValue(Keyword.IN);
+    return this.matchKeywordValue(Keyword.IN) || this.matchKeywordValue(Keyword.NOT_IN);
   }
 
   matchFunction(): boolean {
@@ -317,7 +337,7 @@ export class JsonTemplateLexer {
   }
 
   private static isIdStart(ch: string) {
-    return ch === '$' || ch === '_' || (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z');
+    return ch === '_' || (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z');
   }
 
   private static isIdPart(ch: string) {
@@ -383,7 +403,7 @@ export class JsonTemplateLexer {
         JsonTemplateLexer.validateID(id);
         return {
           type: TokenType.ID,
-          value: id.replace(/^\$/, `${BINDINGS_PARAM_KEY}`),
+          value: id,
           range: [start, this.idx],
         };
     }
@@ -565,7 +585,7 @@ export class JsonTemplateLexer {
     const start = this.idx;
     const ch1 = this.codeChars[this.idx];
 
-    if (',;:{}()[]^+-*/%!><|=@~#?\n'.includes(ch1)) {
+    if (',;:{}()[]^+-*/%!><|=@~$#?\n'.includes(ch1)) {
       return {
         type: TokenType.PUNCT,
         value: ch1,
@@ -594,7 +614,7 @@ export class JsonTemplateLexer {
     const ch1 = this.codeChars[this.idx];
     const ch2 = this.codeChars[this.idx + 1];
 
-    if (ch1 === '~' && 'rs'.includes(ch2)) {
+    if (ch1 === '~' && 'rsj'.includes(ch2)) {
       this.idx += 2;
       return {
         type: TokenType.PUNCT,

src/operators.ts

@@ -23,7 +23,7 @@ function endsWith(val1, val2): string {
 }
 
 function containsStrict(val1, val2): string {
-  return `(typeof ${val1} === 'string' && ${val1}.includes(${val2}))`;
+  return `((typeof ${val1} === 'string' || Array.isArray(${val1})) && ${val1}.includes(${val2}))`;
 }
 
 function contains(val1, val2): string {
@@ -74,10 +74,18 @@ export const binaryOperators = {
 
   '=$': (val1, val2): string => endsWith(val2, val1),
 
+  contains: containsStrict,
+
   '==*': (val1, val2): string => containsStrict(val2, val1),
 
   '=*': (val1, val2): string => contains(val2, val1),
 
+  size: (val1, val2): string => `${val1}.length === ${val2}`,
+
+  empty: (val1, val2): string => `(${val1}.length === 0) === ${val2}`,
+
+  subsetof: (val1, val2): string => `${val1}.every((el) => {return ${val2}.includes(el);})`,
+
   '+': (val1, val2): string => `${val1}+${val2}`,
 
   '-': (val1, val2): string => `${val1}-${val2}`,