feat(api-service): Nv 5777 incorrect preview payload structure fix

apps/api/src/app/workflows-v2/usecases/create-variables-object/create-variables-object.usecase.ts

@@ -1,9 +1,10 @@
+import lodash from 'lodash';
 import { Injectable } from '@nestjs/common';
 import { ControlValuesRepository, EnvironmentEntity, OrganizationEntity, UserEntity } from '@novu/dal';
 import { ControlValuesLevelEnum, FeatureFlagsKeysEnum } from '@novu/shared';
 import { FeatureFlagsService, Instrument, InstrumentUsecase } from '@novu/application-generic';
 
-import { keysToObject } from '../../util/utils';
+import { collectKeys, keysToObject } from '../../util/utils';
 import { buildVariables } from '../../util/build-variables';
 import { CreateVariablesObjectCommand } from './create-variables-object.command';
 import { isStringifiedMailyJSONContent } from '../../../environments-v1/usecases/output-renderers/maily-to-liquid/wrap-maily-in-liquid.command';
@@ -65,20 +66,56 @@ export class CreateVariablesObject {
       );
 
       const hasUsedEvents = !!(step.events && typeof step.events === 'string');
-      if (hasUsedEventCount || hasUsedEventsLength || hasUsedEvents) {
-        step.events = Array.isArray(step.events)
-          ? step.events
+      const { events } = step;
+      /**
+       * Check if events is an object and has a payload property.
+       */
+      const hasUsedEventsWithPayload = !!(
+        events &&
+        typeof events === 'object' &&
+        !Array.isArray(events) &&
+        'payload' in events
+      );
+      let variableNameAfterPayload = hasUsedEventsWithPayload ? ['name'] : [];
+      if (hasUsedEventsWithPayload) {
+        /**
+         * If events is an object and has a payload property, collect keys from the payload.
+         * e.g. [payload.foo.bar]
+         */
+        variableNameAfterPayload = collectKeys(events.payload);
+      }
+
+      if (hasUsedEventCount || hasUsedEventsLength || hasUsedEvents || hasUsedEventsWithPayload) {
+        step.events = Array.isArray(events)
+          ? events
           : Array.from({ length: DEFAULT_ARRAY_ELEMENTS }, (_, index) => {
-              return {
-                payload: { name: `event-${index}` },
-              };
+              let payload = {};
+              for (const variableName of variableNameAfterPayload) {
+                payload = { ...payload, ...this.setNestedValue(payload, variableName, `event-${index}`) };
+              }
+
+              return { payload };
             });
       }
     });
 
     return variablesObject;
   }
 
+  private setNestedValue(obj: Record<string, unknown>, path: string, value: string) {
+    const keys = path.split('.');
+
+    const val = keys.reduceRight((acc, key, index) => {
+      if (index === keys.length - 1) {
+        return { [key]: value };
+      } else {
+        return { [key]: acc };
+      }
+    }, {});
+
+    return lodash.merge(obj, val);
+  }
+
   private async getControlValues(command: CreateVariablesObjectCommand) {
     if (command.controlValues) {
       return [command.controlValues].flat().flatMap((obj) => Object.values(obj));

apps/api/src/app/workflows-v2/util/build-variables.ts

@@ -1,12 +1,11 @@
-import _ from 'lodash';
-import { AdditionalOperation, RulesLogic } from 'json-logic-js';
 import { PinoLogger } from '@novu/application-generic';
+import { AdditionalOperation, RulesLogic } from 'json-logic-js';
 
-import { extractLiquidTemplateVariables, TemplateVariables } from './template-parser/liquid-parser';
-import { WrapMailyInLiquidUseCase } from '../../environments-v1/usecases/output-renderers/maily-to-liquid/wrap-maily-in-liquid.usecase';
 import { isStringifiedMailyJSONContent } from '../../environments-v1/usecases/output-renderers/maily-to-liquid/wrap-maily-in-liquid.command';
+import { WrapMailyInLiquidUseCase } from '../../environments-v1/usecases/output-renderers/maily-to-liquid/wrap-maily-in-liquid.usecase';
 import { extractFieldsFromRules, isValidRule } from '../../shared/services/query-parser/query-parser.service';
 import { JSONSchemaDto } from '../dtos';
+import { extractLiquidTemplateVariables, TemplateVariables } from './template-parser/liquid-parser';
 
 export function buildVariables(
   variableSchema: JSONSchemaDto | undefined,

apps/api/src/app/workflows-v2/util/template-parser/liquid-parser.ts

@@ -1,7 +1,14 @@
-import { Filter, Liquid, LiquidError, Output, RenderError, Template, TokenKind } from 'liquidjs';
 import { FILTER_VALIDATORS, LiquidFilterIssue } from '@novu/framework/internal';
+
+import { Filter, Liquid, LiquidError, Output, RenderError, Template, TokenKind } from 'liquidjs';
+import {
+  DIGEST_EVENTS_VARIABLE_PATTERN,
+  extractLiquidExpressions,
+  isValidDynamicPath,
+  isValidTemplate,
+  VALID_DYNAMIC_PATHS,
+} from './parser-utils';
 import { JSONSchemaDto } from '../../dtos';
-import { extractLiquidExpressions, isValidTemplate } from './parser-utils';
 
 const LIQUID_CONFIG = {
   strictVariables: true,
@@ -245,6 +252,40 @@ function parseByLiquid({
         const isAllowedVariable = isPropertyAllowed(variableSchema, variableName);
         if (isAllowedVariable) {
           validVariables.push({ name: variableName, output: rawOutput });
+          if (filters.length > 0) {
+            filters.forEach((filter) => {
+              const { args } = filter;
+              const firstArg = args[0];
+              if (
+                filter.name === 'toSentence' &&
+                args.length > 0 &&
+                'content' in firstArg &&
+                typeof firstArg.content === 'string'
+              ) {
+                /**
+                 * Check if the parent variable with the first argument is allowed
+                 * basically forcing it to check if additionalProperties is true by checking for final variable name
+                 * and if the parent variable is a valid dynamic path as variableSchema can be undefined.
+                 * OR
+                 * Check if the variable is a digest events array variable
+                 * and the first argument starts with payload.
+                 */
+                if (
+                  (isValidDynamicPath(variableName) &&
+                    isPropertyAllowed(variableSchema, `${variableName}.${firstArg.content}`)) ||
+                  (firstArg.content.startsWith('payload.') && DIGEST_EVENTS_VARIABLE_PATTERN.test(variableName))
+                ) {
+                  const isFirstArgValid = isPropertyAllowed(variableSchema, firstArg.content);
+                  if (isFirstArgValid) {
+                    validVariables.push({
+                      name: `${variableName}.${firstArg.content}`,
+                      output: `{{${firstArg.content}}}`,
+                    });
+                  }
+                }
+              }
+            });
+          }
         } else {
           invalidVariables.push({
             name: variableName,

apps/api/src/app/workflows-v2/util/template-parser/parser-utils.ts

@@ -18,3 +18,12 @@ export function extractLiquidExpressions(str: string): string[] {
 
   return str.match(LIQUID_EXPRESSION_PATTERN) || [];
 }
+
+export const DIGEST_EVENTS_VARIABLE_PATTERN = /^steps\.[^.]+\.events/;
+export const VALID_DYNAMIC_PATHS = ['subscriber.data.', 'payload.', /^steps\.[^.]+\.events\[\d+\]\.payload\./] as const;
+
+export function isValidDynamicPath(variableName: string): boolean {
+  return VALID_DYNAMIC_PATHS.some((path) =>
+    typeof path === 'string' ? variableName.startsWith(path) : path.test(variableName)
+  );
+}