feat: refactor mapping validators

src/engine.test.ts

@@ -1,4 +1,5 @@
 import { JsonTemplateEngine } from './engine';
+import { PathType } from './types';
 
 describe('engine', () => {
   describe('isValidJSONPath', () => {
@@ -66,4 +67,25 @@ describe('engine', () => {
       ).toThrowError('Invalid mapping');
     });
   });
+  describe('isValidMapping', () => {
+    it('should convert to JSON paths when options are used', () => {
+      expect(
+        JsonTemplateEngine.isValidMapping(
+          {
+            input: '$.events[1]',
+            output: 'events[1].name',
+          },
+          { defaultPathType: PathType.JSON },
+        ),
+      ).toBeTruthy();
+    });
+    it('should throw error when output is not valid json path without engine options', () => {
+      expect(
+        JsonTemplateEngine.isValidMapping({
+          input: '$.events[2]',
+          output: 'events[2].name',
+        }),
+      ).toBeFalsy();
+    });
+  });
 });

src/engine.ts

@@ -59,20 +59,57 @@
     }
   }
 
-  private static prepareMappings(mappings: FlatMappingPaths[]): FlatMappingPaths[] {
-    return mappings.map((mapping) => ({
+  private static toJsonPath(input: string): string {
+    if (input.startsWith('$')) {
+      return input;
+    }
+
+    // Check if it's wrapped in quotes
+    // or is a simple identifier
+    // or contains dots
+    if (
+      /^'.*'$/.test(input) ||
+      /^".*"$/.test(input) ||
+      /^\w+$/.test(input) ||
+      input.includes('.')
+    ) {
+      return `$.${input}`;
+    }
+
+    // If input contains special characters
+    return `$.'${input}'`;
+  }
+
+  private static convertToJSONPath(path?: string, options?: EngineOptions): string | undefined {
+    if (!path) {
+      return path;
+    }
+    if (options?.defaultPathType === PathType.JSON) {
+      return JsonTemplateEngine.toJsonPath(path);
+    }
+    return path;
+  }
+
+  private static prepareMapping(mapping: FlatMappingPaths, options?: EngineOptions) {
+    return {
       ...mapping,
       input: mapping.input ?? mapping.from,
-      output: mapping.output ?? mapping.to,
-    }));
+      output: JsonTemplateEngine.convertToJSONPath(mapping.output ?? mapping.to, options),
+    };
+  }
+
+  private static prepareMappings(
+    mappings: FlatMappingPaths[],
+    options?: EngineOptions,
+  ): FlatMappingPaths[] {
+    return mappings
+      .map((mapping) => JsonTemplateEngine.prepareMapping(mapping, options))
+      .filter((mapping) => mapping.input && mapping.output);
   }
 
   static validateMappings(mappings: FlatMappingPaths[], options?: EngineOptions) {
-    JsonTemplateEngine.prepareMappings(mappings).forEach((mapping) => {
-      if (
-        !JsonTemplateEngine.isValidJSONPath(mapping.input) ||
-        !JsonTemplateEngine.isValidJSONPath(mapping.output)
-      ) {
+    JsonTemplateEngine.prepareMappings(mappings, options).forEach((mapping) => {
+      if (!JsonTemplateEngine.isValidJSONPath(mapping.output)) {
         throw new JsonTemplateMappingError(
           'Invalid mapping: invalid JSON path',
           mapping.input as string,
@@ -83,12 +120,21 @@
     JsonTemplateEngine.parseMappingPaths(mappings, options);
   }
 
+  static isValidMapping(mapping: FlatMappingPaths, options?: EngineOptions) {
+    try {
+      JsonTemplateEngine.validateMappings([mapping], options);
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+
   private static createFlatMappingsAST(
     mappings: FlatMappingPaths[],
     options?: EngineOptions,
   ): FlatMappingAST[] {
     const newOptions = { ...options, mappings: true };
-    return JsonTemplateEngine.prepareMappings(mappings)
+    return JsonTemplateEngine.prepareMappings(mappings, options)
       .filter((mapping) => mapping.input && mapping.output)
       .map((mapping) => ({
         ...mapping,

src/parser.ts

@@ -57,11 +57,11 @@ type PathTypeResult = {
 };
 
 export class JsonTemplateParser {
-  private lexer: JsonTemplateLexer;
+  private readonly lexer: JsonTemplateLexer;
 
-  private options?: EngineOptions;
+  private readonly options?: EngineOptions;
 
-  private pathTypesStack: PathTypeResult[] = [];
+  private readonly pathTypesStack: PathTypeResult[] = [];
 
   // indicates currently how many loops being parsed
   private loopCount = 0;

src/reverse_translator.ts

@@ -38,7 +38,7 @@ import { BINDINGS_PARAM_KEY, DATA_PARAM_KEY, EMPTY_EXPR, INDENTATION_SPACES } fr
 import { escapeStr } from './utils';
 
 export class JsonTemplateReverseTranslator {
-  private options?: EngineOptions;
+  private readonly options?: EngineOptions;
 
   private level = 0;
 

src/utils/converter.test.ts

@@ -0,0 +1,14 @@
+import { SyntaxType } from '../types';
+import { convertToObjectMapping } from './converter';
+
+describe('Converter:', () => {
+  describe('convertToObjectMapping', () => {
+    it('should validate mappings', () => {
+      expect(() =>
+        convertToObjectMapping([
+          { inputExpr: { type: SyntaxType.EMPTY }, outputExpr: { type: SyntaxType.EMPTY } },
+        ] as any),
+      ).toThrowError(/Invalid mapping/);
+    });
+  });
+});

test/scenarios/mappings/data.ts

@@ -214,10 +214,6 @@ export const data: Scenario[] = [
     mappingsPath: 'invalid_object_mappings.json',
     error: 'Invalid mapping',
   },
-  {
-    mappingsPath: 'invalid_output_mapping.json',
-    error: 'Invalid mapping',
-  },
   {
     mappingsPath: 'mappings_with_root_fields.json',
     input,
@@ -293,6 +289,16 @@ export const data: Scenario[] = [
       ],
     },
   },
+  {
+    mappingsPath: 'non_path_output.json',
+    output: {
+      'Content-Type': 'application/json',
+      'a.b.c': 3,
+      bar: 1,
+      c: { 'Content-Type': 'text/plain' },
+      'x-bar': 2,
+    },
+  },
   {
     mappingsPath: 'object_mappings.json',
     input: {

test/scenarios/mappings/non_path_output.json

@@ -0,0 +1,26 @@
+[
+  {
+    "input": "'application/json'",
+    "output": "Content-Type"
+  },
+  {
+    "input": "1",
+    "output": "bar"
+  },
+  {
+    "input": "2",
+    "output": "x-bar"
+  },
+  {
+    "input": "2",
+    "description": "This mapping will be ignored because the output is not defined"
+  },
+  {
+    "input": "3",
+    "output": "'a.b.c'"
+  },
+  {
+    "input": "'text/plain'",
+    "output": "c.'Content-Type'"
+  }
+]