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',
+          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/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,
@@ -92,7 +93,11 @@ function processAllFilter(
     !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 +115,10 @@ function processWildCardSelector(
   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 +259,10 @@ function handleRootOnlyOutputMapping(flatMapping: FlatMappingAST, outputAST: Obj
 
 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/data.ts

@@ -150,15 +150,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',