feat: add validator utils

src/engine.test.ts

@@ -0,0 +1,69 @@
+import { JsonTemplateEngine } from './engine';
+
+describe('engine', () => {
+  describe('isValidJSONPath', () => {
+    it('should return true for valid JSON root path', () => {
+      expect(JsonTemplateEngine.isValidJSONPath('$.user.name')).toBeTruthy();
+    });
+
+    it('should return true for valid JSON relative path', () => {
+      expect(JsonTemplateEngine.isValidJSONPath('.user.name')).toBeTruthy();
+
+      expect(JsonTemplateEngine.isValidJSONPath('@.user.name')).toBeTruthy();
+    });
+
+    it('should return false for invalid JSON path', () => {
+      expect(JsonTemplateEngine.isValidJSONPath('userId')).toBeFalsy();
+    });
+
+    it('should return false for invalid template', () => {
+      expect(JsonTemplateEngine.isValidJSONPath('a=')).toBeFalsy();
+    });
+
+    it('should return false for empty path', () => {
+      expect(JsonTemplateEngine.isValidJSONPath('')).toBeFalsy();
+    });
+  });
+  describe('validateMappings', () => {
+    it('should validate mappings', () => {
+      expect(() =>
+        JsonTemplateEngine.validateMappings([
+          {
+            input: '$.userId',
+            output: '$.user.id',
+          },
+          {
+            input: '$.discount',
+            output: '$.events[0].items[*].discount',
+          },
+        ]),
+      ).not.toThrow();
+    });
+
+    it('should throw error for mappings which are not compatible with each other', () => {
+      expect(() =>
+        JsonTemplateEngine.validateMappings([
+          {
+            input: '$.events[0]',
+            output: '$.events[0].name',
+          },
+          {
+            input: '$.discount',
+            output: '$.events[0].name[*].discount',
+          },
+        ]),
+      ).toThrowError('Invalid mapping');
+    });
+
+    it('should throw error for mappings with invalid json paths', () => {
+      expect(() =>
+        JsonTemplateEngine.validateMappings([
+          {
+            input: 'events[0]',
+            output: 'events[0].name',
+          },
+        ]),
+      ).toThrowError('Invalid mapping');
+    });
+  });
+});

src/engine.ts

@@ -1,10 +1,18 @@
 /* eslint-disable import/no-cycle */
 import { BINDINGS_PARAM_KEY, DATA_PARAM_KEY, EMPTY_EXPR } from './constants';
+import { JsonTemplateMappingError } from './errors/mapping';
 import { JsonTemplateLexer } from './lexer';
 import { JsonTemplateParser } from './parser';
 import { JsonTemplateReverseTranslator } from './reverse_translator';
 import { JsonTemplateTranslator } from './translator';
-import { EngineOptions, Expression, FlatMappingPaths, TemplateInput } from './types';
+import {
+  EngineOptions,
+  Expression,
+  FlatMappingPaths,
+  PathType,
+  SyntaxType,
+  TemplateInput,
+} from './types';
 import { CreateAsyncFunction, convertToObjectMapping, isExpression } from './utils';
 
 export class JsonTemplateEngine {
@@ -36,13 +44,46 @@ export class JsonTemplateEngine {
     return translator.translate();
   }
 
+  static isValidJSONPath(path: string = ''): boolean {
+    try {
+      const expression = JsonTemplateEngine.parse(path, { defaultPathType: PathType.JSON });
+      const statement = expression.statements?.[0];
+      return (
+        statement &&
+        statement.type === SyntaxType.PATH &&
+        (!statement.root || statement.root === DATA_PARAM_KEY)
+      );
+    } catch (e) {
+      return false;
+    }
+  }
+
+  private static prepareMappings(mappings: FlatMappingPaths[]): FlatMappingPaths[] {
+    return mappings.map((mapping) => ({
+      ...mapping,
+      input: mapping.input ?? mapping.from,
+      output: mapping.output ?? mapping.to,
+    }));
+  }
+
+  static validateMappings(mappings: FlatMappingPaths[]) {
+    JsonTemplateEngine.prepareMappings(mappings).forEach((mapping) => {
+      if (
+        !JsonTemplateEngine.isValidJSONPath(mapping.input) ||
+        !JsonTemplateEngine.isValidJSONPath(mapping.output)
+      ) {
+        throw new JsonTemplateMappingError(
+          'Invalid mapping: invalid JSON path',
+          mapping.input as string,
+          mapping.output as string,
+        );
+      }
+    });
+    JsonTemplateEngine.parseMappingPaths(mappings);
+  }
+
   static parseMappingPaths(mappings: FlatMappingPaths[], options?: EngineOptions): Expression {
-    const flatMappingAST = mappings
-      .map((mapping) => ({
-        ...mapping,
-        input: mapping.input ?? mapping.from,
-        output: mapping.output ?? mapping.to,
-      }))
+    const flatMappingAST = JsonTemplateEngine.prepareMappings(mappings)
       .filter((mapping) => mapping.input && mapping.output)
       .map((mapping) => ({
         ...mapping,

src/errors/index.ts

@@ -0,0 +1,3 @@
+export * from './lexer';
+export * from './parser';
+export * from './translator';

src/errors/lexer.ts

@@ -0,0 +1 @@
+export class JsonTemplateLexerError extends Error {}

src/errors/mapping.ts

@@ -0,0 +1,11 @@
+export class JsonTemplateMappingError extends Error {
+  inputMapping: string;
+
+  outputMapping: string;
+
+  constructor(message: string, inputMapping: string, outputMapping: string) {
+    super(`${message}. Input: ${inputMapping}, Output: ${outputMapping}`);
+    this.inputMapping = inputMapping;
+    this.outputMapping = outputMapping;
+  }
+}

src/errors/parser.ts

@@ -0,0 +1 @@
+export class JsonTemplateParserError extends Error {}

src/errors/translator.ts

@@ -0,0 +1 @@
+export class JsonTemplateTranslatorError extends Error {}

src/lexer.ts

@@ -1,5 +1,5 @@
 import { VARS_PREFIX } from './constants';
-import { JsonTemplateLexerError } from './errors';
+import { JsonTemplateLexerError } from './errors/lexer';
 import { Keyword, Token, TokenType } from './types';
 
 const MESSAGES = {

src/parser.ts

@@ -1,7 +1,8 @@
 /* eslint-disable import/no-cycle */
 import { BINDINGS_PARAM_KEY, DATA_PARAM_KEY, EMPTY_EXPR } from './constants';
 import { JsonTemplateEngine } from './engine';
-import { JsonTemplateLexerError, JsonTemplateParserError } from './errors';
+import { JsonTemplateParserError } from './errors/parser';
+import { JsonTemplateLexerError } from './errors/lexer';
 import { JsonTemplateLexer } from './lexer';
 import {
   ArrayExpression,

src/reverse_translator.ts

@@ -48,7 +48,6 @@ export class JsonTemplateReverseTranslator {
   translate(expr: Expression): string {
     let code: string = this.translateExpression(expr);
     code = code.replace(/\.\s+\./g, '.');
-    // code = code.replace(/\s+\./g, '.');
     if (this.options?.defaultPathType === PathType.JSON) {
       code = code.replace(/\^/g, '$');
     }

src/translator.ts

@@ -6,7 +6,7 @@ import {
   RESULT_KEY,
   VARS_PREFIX,
 } from './constants';
-import { JsonTemplateTranslatorError } from './errors';
+import { JsonTemplateTranslatorError } from './errors/translator';
 import { binaryOperators, isStandardFunction, standardFunctions } from './operators';
 import {
   ArrayExpression,

src/utils/converter.ts

@@ -1,4 +1,5 @@
 /* eslint-disable no-param-reassign */
+import { JsonTemplateMappingError } from '../errors/mapping';
 import { EMPTY_EXPR } from '../constants';
 import {
   SyntaxType,
@@ -67,10 +68,35 @@
 
   if (filterIndex === -1) {
     if (currentOutputPropAST.value.type === SyntaxType.OBJECT_EXPR) {
-      return currentOutputPropAST.value as ObjectExpression;
+      const currObjectExpr = currentOutputPropAST.value as ObjectExpression;
+      currentOutputPropAST.value = {
+        type: SyntaxType.PATH,
+        root: currObjectExpr,
+        pathType: currentInputAST.pathType,
+        inferredPathType: currentInputAST.inferredPathType,
+        parts: [],
+        returnAsArray: true,
+      } as PathExpression;
+      return currObjectExpr;
+    }
+
+    if (
+      currentOutputPropAST.value.type === SyntaxType.PATH &&
+      currentOutputPropAST.value.parts.length === 0 &&
+      currentOutputPropAST.value.root?.type === SyntaxType.OBJECT_EXPR
+    ) {
+      return currentOutputPropAST.value.root as ObjectExpression;
     }
   } else {
     const matchedInputParts = currentInputAST.parts.splice(0, filterIndex + 1);
+    if (
+      currentOutputPropAST.value.type === SyntaxType.PATH &&
+      currentOutputPropAST.value.parts.length === 0 &&
+      currentOutputPropAST.value.root?.type === SyntaxType.OBJECT_EXPR
+    ) {
+      currentOutputPropAST.value = currentOutputPropAST.value.root;
+    }
+
     if (currentOutputPropAST.value.type !== SyntaxType.PATH) {
       matchedInputParts.push(createBlockExpression(currentOutputPropAST.value));
       currentOutputPropAST.value = {
@@ -92,7 +118,11 @@
     !objectExpr.props ||
     !Array.isArray(objectExpr.props)
   ) {
-    throw new Error(`Failed to process output mapping: ${flatMapping.output}`);
+    throw new JsonTemplateMappingError(
+      'Invalid mapping',
+      flatMapping.input as string,
+      flatMapping.output as string,
+    );
   }
   return objectExpr;
 }
@@ -110,8 +140,10 @@
   const filterIndex = currentInputAST.parts.findIndex(isWildcardSelector);
 
   if (filterIndex === -1) {
-    throw new Error(
-      `Invalid object mapping: input=${flatMapping.input} and output=${flatMapping.output}`,
+    throw new JsonTemplateMappingError(
+      'Invalid mapping',
+      flatMapping.input as string,
+      flatMapping.output as string,
     );
   }
   const matchedInputParts = currentInputAST.parts.splice(0, filterIndex);
@@ -252,8 +284,10 @@
 
 function validateMapping(flatMapping: FlatMappingAST) {
   if (flatMapping.outputExpr.type !== SyntaxType.PATH) {
-    throw new Error(
-      `Invalid object mapping: output=${flatMapping.output} should be a path expression`,
+    throw new JsonTemplateMappingError(
+      'Invalid mapping: should be a path expression',
+      flatMapping.input as string,
+      flatMapping.output as string,
     );
   }
 }

test/scenarios/mappings/all_features.json

@@ -11,6 +11,10 @@
     "input": "$.products[?(@.category)].id",
     "output": "$.events[0].items[*].product_id"
   },
+  {
+    "input": "$.coupon",
+    "output": "$.events[0].items[*].coupon_code"
+  },
   {
     "input": "$.events[0]",
     "output": "$.events[0].name"

test/scenarios/mappings/data.ts

@@ -76,6 +76,7 @@ export const data: Scenario[] = [
             {
               discount: 10,
               product_id: 1,
+              coupon_code: 'DISCOUNT',
               product_name: 'p1',
               product_category: 'baby',
               options: [
@@ -92,6 +93,7 @@ export const data: Scenario[] = [
             {
               discount: 10,
               product_id: 3,
+              coupon_code: 'DISCOUNT',
               product_name: 'p3',
               product_category: 'home',
               options: [
@@ -150,15 +152,15 @@ export const data: Scenario[] = [
   },
   {
     mappingsPath: 'invalid_array_mappings.json',
-    error: 'Failed to process output mapping',
+    error: 'Invalid mapping',
   },
   {
     mappingsPath: 'invalid_object_mappings.json',
-    error: 'Invalid object mapping',
+    error: 'Invalid mapping',
   },
   {
     mappingsPath: 'invalid_output_mapping.json',
-    error: 'Invalid object mapping',
+    error: 'Invalid mapping',
   },
   {
     mappingsPath: 'mappings_with_root_fields.json',
@@ -399,6 +401,21 @@ export const data: Scenario[] = [
       },
     },
   },
+  {
+    mappingsPath: 'simple_array_mappings.json',
+    input: {
+      user_id: 1,
+      user_name: 'John Doe',
+    },
+    output: {
+      users: [
+        {
+          id: 1,
+          name: 'John Doe',
+        },
+      ],
+    },
+  },
   {
     input: {
       a: [

test/scenarios/mappings/simple_array_mappings.json

@@ -0,0 +1,10 @@
+[
+  {
+    "input": "$.user_id",
+    "output": "$.users[*].id"
+  },
+  {
+    "input": "$.user_name",
+    "output": "$.users[*].name"
+  }
+]