fix(api): Return all relevant subscriber fields as test data

Return all subscriber fields as the test data.to field based on the variables used in the workflow and the steps that the workflow includes.

That is, an SMS step requires a phone, an Email step an email and any other field should be present in the To test data object if it's used as a variable in the content of the workflow steps.

Author: SokratisVidros

apps/api/src/app/workflows-v2/usecases/build-test-data/build-workflow-test-data.usecase.ts

@@ -6,6 +6,7 @@ import {
   StepTypeEnum,
   UserSessionData,
   WorkflowTestDataResponseDto,
+  Variables,
 } from '@novu/shared';
 import {
   GetWorkflowByIdsCommand,
@@ -30,7 +31,16 @@ export class BuildWorkflowTestDataUseCase {
   @InstrumentUsecase()
   async execute(command: WorkflowTestDataCommand): Promise<WorkflowTestDataResponseDto> {
     const workflow = await this.fetchWorkflow(command);
-    const toSchema = this.buildToFieldSchema({ user: command.user, steps: workflow.steps });
+    const variables = await this.extractVariables.execute(
+      ExtractVariablesCommand.create({
+        environmentId: command.user.environmentId,
+        organizationId: command.user.organizationId,
+        userId: command.user._id,
+        workflowId: workflow._id,
+      })
+    );
+    const toSchema = this.buildToFieldSchema({ user: command.user, steps: workflow.steps, variables });
+
     const payloadSchema = await this.resolvePayloadSchema(workflow, command);
     const payloadSchemaMock = this.generatePayloadMock(payloadSchema);
 
@@ -84,38 +94,58 @@ export class BuildWorkflowTestDataUseCase {
   private buildToFieldSchema({
     user,
     steps,
+    variables,
   }: {
     user: UserSessionData;
     steps: NotificationStepEntity[];
+    variables: Variables;
   }): JSONSchemaDto {
-    const hasEmailStep = this.hasStepType(steps, StepTypeEnum.EMAIL);
-    const hasSmsStep = this.hasStepType(steps, StepTypeEnum.SMS);
-
-    const properties: { [key: string]: JSONSchemaDto } = {
-      subscriberId: { type: 'string', default: user._id },
-    };
+    // TODO: add subscriber schema
+    const toSchema = buildVariablesSchema({});
 
     const required: string[] = ['subscriberId'];
+    toSchema.properties!.subscriberId = { type: 'string', default: user._id };
 
-    if (hasEmailStep) {
-      properties.email = { type: 'string', default: user.email ?? '', format: 'email' };
+    if (this.hasStep(steps, StepTypeEnum.EMAIL)) {
+      toSchema.properties!.email = { type: 'string', default: user.email ?? '', format: 'email' };
       required.push('email');
     }
 
-    if (hasSmsStep) {
-      properties.phone = { type: 'string', default: '' };
+    if (this.hasStep(steps, StepTypeEnum.SMS)) {
+      toSchema.properties!.phone = { type: 'string', default: '' };
       required.push('phone');
     }
 
-    return {
-      type: 'object',
-      properties,
-      required,
-      additionalProperties: false,
-    } satisfies JSONSchemaDto;
+    if (variables.subscriber.firstName) {
+      toSchema.properties!.firstName = { type: 'string', default: user.firstName || '' };
+    }
+
+    if (variables.subscriber.lastName) {
+      toSchema.properties!.lastName = { type: 'string', default: user.lastName || '' };
+    }
+
+    if (variables.subscriber.isOnline) {
+      toSchema.properties!.avatar = { type: 'boolean', default: true };
+    }
+
+    if (variables.subscriber.isLastOnline) {
+      toSchema.properties!.avatar = { type: 'string', format: 'date-time', default: new Date().toISOString() };
+    }
+
+    // TODO: add locale as an enum
+    if (variables.subscriber.locale) {
+      toSchema.properties!.locale = { type: 'string', default: '' };
+    }
+
+    // TODO: add timezone as an enum
+    if (variables.subscriber.timezone) {
+      toSchema.properties!.timezone = { type: 'string', default: '' };
+    }
+
+    return toSchema;
   }
 
-  private hasStepType(steps: NotificationStepEntity[], type: StepTypeEnum): boolean {
+  private hasStep(steps: NotificationStepEntity[], type: StepTypeEnum): boolean {
     return steps.some((step) => step.template?.type === type);
   }
 }

apps/api/src/app/workflows-v2/usecases/build-variable-schema/build-available-variable-schema.usecase.ts

@@ -37,13 +37,14 @@ export class BuildVariableSchemaUsecase {
           type: 'object',
           description: 'Schema representing the subscriber entity',
           properties: {
+            subscriberId: { type: 'string', description: 'Unique identifier for the subscriber' },
             firstName: { type: 'string', description: "Subscriber's first name" },
             lastName: { type: 'string', description: "Subscriber's last name" },
             email: { type: 'string', description: "Subscriber's email address" },
             phone: { type: 'string', description: "Subscriber's phone number (optional)" },
             avatar: { type: 'string', description: "URL to the subscriber's avatar image (optional)" },
             locale: { type: 'string', description: 'Locale for the subscriber (optional)' },
-            subscriberId: { type: 'string', description: 'Unique identifier for the subscriber' },
+            timezone: { type: 'string', description: 'Timezone for the subscriber (optional)' },
             isOnline: { type: 'boolean', description: 'Indicates if the subscriber is online (optional)' },
             lastOnlineAt: {
               type: 'string',

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

@@ -1,6 +1,6 @@
 import { Injectable } from '@nestjs/common';
 import { ControlValuesRepository } from '@novu/dal';
-import { ControlValuesLevelEnum } from '@novu/shared';
+import { ControlValuesLevelEnum, Variables } from '@novu/shared';
 import { Instrument, InstrumentUsecase } from '@novu/application-generic';
 
 import { keysToObject } from '../../util/utils';
@@ -12,11 +12,11 @@ export class ExtractVariables {
   constructor(private readonly controlValuesRepository: ControlValuesRepository) {}
 
   @InstrumentUsecase()
-  async execute(command: ExtractVariablesCommand): Promise<Record<string, unknown>> {
+  async execute(command: ExtractVariablesCommand) {
     const controlValues = await this.getControlValues(command);
     const extractedVariables = await this.extractAllVariables(controlValues);
 
-    return keysToObject(extractedVariables);
+    return keysToObject<Variables>(extractedVariables);
   }
 
   private async getControlValues(command: ExtractVariablesCommand) {