feat: add support for mappings

src/common/types.ts

@@ -1,3 +1,4 @@
+import { FlatMappingPaths } from '@rudderstack/json-template-engine';
 import { type StepExecutionError } from '../errors';
 
 export interface Executor {
@@ -109,17 +110,13 @@ export type SimpleStep = StepCommon & {
   // One of the template, templatePath, externalWorkflowPath, Function are required for simple steps
   template?: string;
   templatePath?: string;
+  mappings?: boolean;
   // external workflow is executed independently and we can access only final output
   externalWorkflow?: ExternalWorkflow;
   // Function must be passed using bindings
   functionName?: string;
 };
 
-export type Template = {
-  content?: string;
-  path?: string;
-};
-
 export type BatchConfig = {
   options?: {
     size?: number;

src/steps/base/simple/executors/template/jsontemplate.ts

@@ -1,13 +1,34 @@
-import { JsonTemplateEngine, PathType } from '@rudderstack/json-template-engine';
-import { ExecutionBindings, Step, StepOutput } from '../../../../../common';
+import {
+  Expression,
+  FlatMappingPaths,
+  JsonTemplateEngine,
+  PathType,
+} from '@rudderstack/json-template-engine';
+import { ExecutionBindings, SimpleStep, StepOutput } from '../../../../../common';
 import { BaseStepExecutor } from '../../../executors/base';
 
 export class JsonTemplateStepExecutor extends BaseStepExecutor {
   private readonly templateEngine: JsonTemplateEngine;
 
-  constructor(step: Step, template: string, bindings?: Record<string, any>) {
+  static parse(template: string, mappings?: boolean, bindings?: Record<string, any>): Expression {
+    if (mappings) {
+      try {
+        const mappingPaths = JSON.parse(template) as FlatMappingPaths[];
+        return JsonTemplateEngine.parse(mappingPaths, { defaultPathType: PathType.JSON });
+      } catch (e) {
+        // parse as template
+      }
+    }
+    return JsonTemplateEngine.parse(template, {
+      defaultPathType: PathType.SIMPLE,
+      compileTimeBindings: bindings,
+    });
+  }
+
+  constructor(step: SimpleStep, template: string, bindings?: Record<string, any>) {
     super(step);
-    this.templateEngine = JsonTemplateEngine.create(template, {
+    const expression = JsonTemplateStepExecutor.parse(template, step.mappings, bindings);
+    this.templateEngine = JsonTemplateEngine.create(expression, {
       compileTimeBindings: bindings,
       defaultPathType: PathType.SIMPLE,
     });

test/scenarios/mappings/data.ts

@@ -0,0 +1,12 @@
+import { Scenario } from '../../types';
+
+export const data: Scenario[] = [
+  {
+    input: {
+      a: 1,
+    },
+    output: {
+      bar: 1,
+    },
+  },
+];

test/scenarios/mappings/workflow.yaml

@@ -0,0 +1,18 @@
+templateType: jsontemplate
+steps:
+  - name: mappings
+    mappings: true
+    description: |
+      InputTemplate will be parsed as normal json template/
+      template will be parsed as mappings.
+    inputTemplate: |
+      {
+        foo: ^.a
+      }
+    template: |
+      [
+        {
+          "input": "$.foo",
+          "output": "$.bar"
+        }
+      ]