feat(framework): Add support for specifying mock results

packages/framework/src/client.test.ts

@@ -4,6 +4,7 @@ import { Client } from './client';
 import {
   ExecutionEventPayloadInvalidError,
   ExecutionStateCorruptError,
+  ExecutionStateResultInvalidError,
   ProviderExecutionFailedError,
   StepExecutionFailedError,
   StepNotFoundError,
@@ -1472,6 +1473,161 @@ describe('Novu Client', () => {
       expect(metadata.duration).toEqual(expect.any(Number));
     });
 
+    it('should use the provided state to mock non previewed step outputs', async () => {
+      const newWorkflow = workflow(
+        'test-workflow',
+        async ({ step }) => {
+          const digestOutput = await step.digest('digest-output', async () => ({
+            type: 'regular',
+            amount: 1,
+            unit: 'seconds',
+          }));
+
+          await step.inApp(
+            'send-email',
+            async () => ({
+              body: digestOutput.events.map((event) => event.payload.comment).join(','),
+            }),
+            {
+              skip: () => true,
+            }
+          );
+        },
+        {
+          payloadSchema: {
+            type: 'object',
+            properties: {
+              comment: { type: 'string' },
+            },
+            required: ['comment'],
+          } as const,
+        }
+      );
+
+      client.addWorkflows([newWorkflow]);
+
+      const event: Event = {
+        action: PostActionEnum.PREVIEW,
+        workflowId: 'test-workflow',
+        stepId: 'send-email',
+        subscriber: {},
+        state: [
+          {
+            stepId: 'digest-output',
+            state: {
+              status: 'success',
+            },
+            outputs: {
+              events: [
+                {
+                  id: '1',
+                  time: '2024-01-01T00:00:00.000Z',
+                  payload: {
+                    comment: 'Hello',
+                  },
+                },
+                {
+                  id: '2',
+                  time: '2024-01-01T00:00:00.000Z',
+                  payload: {
+                    comment: 'World',
+                  },
+                },
+              ],
+            },
+          },
+        ],
+        payload: {},
+        controls: {},
+      };
+
+      const executionResult = await client.executeWorkflow(event);
+
+      expect(executionResult).toBeDefined();
+      expect(executionResult.outputs).toBeDefined();
+      if (!executionResult.outputs) throw new Error('executionResult.outputs is undefined');
+
+      const { body } = executionResult.outputs;
+      expect(body).toBe('Hello,World');
+
+      expect(executionResult.providers).toEqual({});
+
+      const { metadata } = executionResult;
+      expect(metadata.status).toBe('success');
+      expect(metadata.error).toBe(false);
+      expect(metadata.duration).toEqual(expect.any(Number));
+    });
+
+    it('should throw an error when the provided preview state is invalid', async () => {
+      const newWorkflow = workflow(
+        'test-workflow',
+        async ({ step }) => {
+          const digestOutput = await step.digest('digest-output', async () => ({
+            type: 'regular',
+            amount: 1,
+            unit: 'seconds',
+          }));
+
+          await step.inApp(
+            'send-email',
+            async () => ({
+              body: digestOutput.events.map((event) => event.payload.comment).join(','),
+            }),
+            {
+              skip: () => true,
+            }
+          );
+        },
+        {
+          payloadSchema: {
+            type: 'object',
+            properties: {
+              comment: { type: 'string' },
+            },
+            required: ['comment'],
+          } as const,
+        }
+      );
+
+      client.addWorkflows([newWorkflow]);
+
+      const event: Event = {
+        action: PostActionEnum.PREVIEW,
+        workflowId: 'test-workflow',
+        stepId: 'send-email',
+        subscriber: {},
+        state: [
+          {
+            stepId: 'digest-output',
+            state: {
+              status: 'success',
+            },
+            outputs: {
+              events: [
+                {
+                  time: '2024-01-01T00:00:00.000Z',
+                  payload: {
+                    comment: 'Hello',
+                  },
+                },
+                {
+                  id: '2',
+                  time: '2024-01-01T00:00:00.000Z',
+                  payload: {
+                    comment: 'World',
+                  },
+                },
+              ],
+            },
+          },
+        ],
+        payload: {},
+        controls: {},
+      };
+
+      await expect(client.executeWorkflow(event)).rejects.toThrow(ExecutionStateResultInvalidError);
+    });
+
     it('should throw an error when workflow ID is invalid', async () => {
       // non-existing workflow ID
       const event: Event = {

packages/framework/src/client.ts

@@ -31,6 +31,7 @@ import type {
   HealthCheck,
   Schema,
   Skip,
+  State,
   ValidationError,
   Workflow,
 } from './types';
@@ -634,7 +635,7 @@ export class Client {
       }
     } else {
       try {
-        const result = event.state.find((state) => state.stepId === step.stepId);
+        const result = this.getStepState(event, step.stepId);
 
         if (result) {
           const validatedOutput = await this.validate(
@@ -723,7 +724,21 @@ export class Client {
           providers: await this.executeProviders(event, step, validatedOutput),
         };
       } else {
-        const mockResult = this.mock(step.results.schema);
+        let mockResult: Record<string, unknown>;
+        const suppliedResult = this.getStepState(event, step.stepId);
+
+        if (suppliedResult) {
+          mockResult = await this.validate(
+            suppliedResult.outputs,
+            step.results.unknownSchema,
+            'step',
+            'result',
+            event.workflowId,
+            step.stepId
+          );
+        } else {
+          mockResult = this.mock(step.results.schema);
+        }
 
         console.log(`  ${EMOJI.MOCK} Mocked stepId: \`${step.stepId}\``);
 
@@ -743,6 +758,10 @@ export class Client {
     }
   }
 
+  private getStepState(event: Event, stepId: string): State | undefined {
+    return event.state.find((state) => state.stepId === stepId);
+  }
+
   private getStepCode(workflowId: string, stepId: string): CodeResult {
     const step = this.getStep(workflowId, stepId);