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

@@ -1,9 +1,11 @@
+/* eslint-disable import/no-cycle */
 import { BINDINGS_PARAM_KEY, DATA_PARAM_KEY } from './constants';
 import { JsonTemplateLexer } from './lexer';
 import { JsonTemplateParser } from './parser';
+import { JsonTemplateReverseTranslator } from './reverse_translator';
 import { JsonTemplateTranslator } from './translator';
-import { EngineOptions, Expression } from './types';
-import { CommonUtils } from './utils';
+import { EngineOptions, Expression, FlatMappingPaths, TemplateInput } from './types';
+import { CreateAsyncFunction, convertToObjectMapping, isExpression } from './utils';
 
 export class JsonTemplateEngine {
   private readonly fn: Function;
@@ -12,17 +14,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,
@@ -31,40 +22,68 @@ export class JsonTemplateEngine {
     return Function(DATA_PARAM_KEY, BINDINGS_PARAM_KEY, this.translate(templateOrExpr, options));
   }
 
-  private static compileAsAsync(
-    templateOrExpr: string | Expression,
-    options?: EngineOptions,
-  ): Function {
-    return CommonUtils.CreateAsyncFunction(
+  private static compileAsAsync(templateOrExpr: TemplateInput, options?: EngineOptions): Function {
+    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();
+  private static translateExpression(expr: Expression): string {
+    const translator = new JsonTemplateTranslator(expr);
+    return translator.translate();
   }
 
-  static translate(templateOrExpr: string | Expression, options?: EngineOptions): string {
-    if (typeof templateOrExpr === 'string') {
-      return this.translateTemplate(templateOrExpr, options);
+  private static parseMappingPaths(
+    mappings: FlatMappingPaths[],
+    options?: EngineOptions,
+  ): Expression {
+    const flatMappingAST = mappings.map((mapping) => ({
+      ...mapping,
+      inputExpr: JsonTemplateEngine.parse(mapping.input, options).statements[0],
+      outputExpr: JsonTemplateEngine.parse(mapping.output, options).statements[0],
+    }));
+    return convertToObjectMapping(flatMappingAST);
+  }
+
+  static create(templateOrExpr: TemplateInput, 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: TemplateInput, options?: EngineOptions): Expression {
+    if (isExpression(template)) {
+      return template as Expression;
     }
-    return this.translateExpression(templateOrExpr);
+    if (typeof template === 'string') {
+      const lexer = new JsonTemplateLexer(template);
+      const parser = new JsonTemplateParser(lexer, options);
+      return parser.parse();
+    }
+    return this.parseMappingPaths(template as FlatMappingPaths[], options);
   }
 
-  private static translateTemplate(template: string, options?: EngineOptions): string {
+  static translate(template: TemplateInput, options?: EngineOptions): string {
     return this.translateExpression(this.parse(template, options));
   }
 
-  private static translateExpression(expr: Expression): string {
-    const translator = new JsonTemplateTranslator(expr);
-    return translator.translate();
+  static reverseTranslate(expr: Expression, options?: EngineOptions): string {
+    const translator = new JsonTemplateReverseTranslator(options);
+    return translator.translate(expr);
+  }
+
+  static convertMappingsToTemplate(mappings: FlatMappingPaths[], options?: EngineOptions): string {
+    return this.reverseTranslate(this.parseMappingPaths(mappings, options), options);
   }
 
-  evaluate(data: any, bindings: Record<string, any> = {}): any {
+  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,8 +81,12 @@ 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 {
@@ -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,10 +149,38 @@ 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);
+  }
+
+  matchAnyOf(): boolean {
+    return this.matchKeywordValue(Keyword.ANYOF);
+  }
+
+  matchNoneOf(): boolean {
+    return this.matchKeywordValue(Keyword.NONEOF);
+  }
+
   matchIN(): boolean {
     return this.matchKeywordValue(Keyword.IN);
   }
 
+  matchNotIN(): boolean {
+    return this.matchKeywordValue(Keyword.NOT_IN);
+  }
+
   matchFunction(): boolean {
     return this.matchKeywordValue(Keyword.FUNCTION);
   }
@@ -259,7 +291,12 @@ export class JsonTemplateLexer {
       };
     }
 
-    const token = this.scanPunctuator() ?? this.scanID() ?? this.scanString() ?? this.scanInteger();
+    const token =
+      this.scanRegularExpressions() ??
+      this.scanPunctuator() ??
+      this.scanID() ??
+      this.scanString() ??
+      this.scanInteger();
     if (token) {
       return token;
     }
@@ -294,7 +331,8 @@ export class JsonTemplateLexer {
       token.type === TokenType.FLOAT ||
       token.type === TokenType.STR ||
       token.type === TokenType.NULL ||
-      token.type === TokenType.UNDEFINED
+      token.type === TokenType.UNDEFINED ||
+      token.type === TokenType.REGEXP
     );
   }
 
@@ -317,7 +355,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 +421,7 @@ export class JsonTemplateLexer {
         JsonTemplateLexer.validateID(id);
         return {
           type: TokenType.ID,
-          value: id.replace(/^\$/, `${BINDINGS_PARAM_KEY}`),
+          value: id,
           range: [start, this.idx],
         };
     }
@@ -521,7 +559,7 @@ export class JsonTemplateLexer {
         };
       }
     } else if (ch1 === '=') {
-      if ('^$*'.indexOf(ch2) >= 0) {
+      if ('^$*~'.indexOf(ch2) >= 0) {
         this.idx += 2;
         return {
           type: TokenType.PUNCT,
@@ -565,7 +603,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 +632,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,
@@ -618,6 +656,56 @@ export class JsonTemplateLexer {
     }
   }
 
+  private static isValidRegExp(regexp: string, modifiers: string) {
+    try {
+      RegExp(regexp, modifiers);
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+
+  private getRegExpModifiers(): string {
+    let modifiers = '';
+    while ('gimsuyv'.includes(this.codeChars[this.idx])) {
+      modifiers += this.codeChars[this.idx];
+      this.idx++;
+    }
+    return modifiers;
+  }
+
+  private scanRegularExpressions(): Token | undefined {
+    const start = this.idx;
+    const ch1 = this.codeChars[this.idx];
+
+    if (ch1 === '/') {
+      let end = this.idx + 1;
+      while (end < this.codeChars.length) {
+        if (this.codeChars[end] === '\n') {
+          return;
+        }
+        if (this.codeChars[end] === '/') {
+          break;
+        }
+        end++;
+      }
+
+      if (end < this.codeChars.length) {
+        this.idx = end + 1;
+        const regexp = this.getCode(start + 1, end);
+        const modifiers = this.getRegExpModifiers();
+        if (!JsonTemplateLexer.isValidRegExp(regexp, modifiers)) {
+          JsonTemplateLexer.throwError("invalid regular expression '%0'", regexp);
+        }
+        return {
+          type: TokenType.REGEXP,
+          value: this.getCode(start, this.idx),
+          range: [start, this.idx],
+        };
+      }
+    }
+  }
+
   private scanPunctuator(): Token | undefined {
     return (
       this.scanPunctuatorForDots() ??