Fix manual trigger output schema (#8150)

- add schema for manual trigger
- split into sub functions
- handle case with no variables

packages/twenty-server/src/modules/workflow/workflow-builder/utils/generate-fake-object-record-event.ts

@@ -0,0 +1,77 @@
+import { v4 } from 'uuid';
+
+import { ObjectRecordCreateEvent } from 'src/engine/core-modules/event-emitter/types/object-record-create.event';
+import { ObjectRecordDeleteEvent } from 'src/engine/core-modules/event-emitter/types/object-record-delete.event';
+import { ObjectRecordDestroyEvent } from 'src/engine/core-modules/event-emitter/types/object-record-destroy.event';
+import { ObjectRecordUpdateEvent } from 'src/engine/core-modules/event-emitter/types/object-record-update.event';
+import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
+import { generateFakeObjectRecord } from 'src/modules/workflow/workflow-builder/utils/generate-fake-object-record';
+
+export const generateFakeObjectRecordEvent = <Entity>(
+  objectMetadataEntity: ObjectMetadataEntity,
+  action: 'created' | 'updated' | 'deleted' | 'destroyed',
+):
+  | ObjectRecordCreateEvent<Entity>
+  | ObjectRecordUpdateEvent<Entity>
+  | ObjectRecordDeleteEvent<Entity>
+  | ObjectRecordDestroyEvent<Entity> => {
+  const recordId = v4();
+  const userId = v4();
+  const workspaceMemberId = v4();
+
+  const after = generateFakeObjectRecord<Entity>(objectMetadataEntity);
+
+  if (action === 'created') {
+    return {
+      recordId,
+      userId,
+      workspaceMemberId,
+      objectMetadata: objectMetadataEntity,
+      properties: {
+        after,
+      },
+    } satisfies ObjectRecordCreateEvent<Entity>;
+  }
+
+  const before = generateFakeObjectRecord<Entity>(objectMetadataEntity);
+
+  if (action === 'updated') {
+    return {
+      recordId,
+      userId,
+      workspaceMemberId,
+      objectMetadata: objectMetadataEntity,
+      properties: {
+        before,
+        after,
+        diff: after,
+      },
+    } satisfies ObjectRecordUpdateEvent<Entity>;
+  }
+
+  if (action === 'deleted') {
+    return {
+      recordId,
+      userId,
+      workspaceMemberId,
+      objectMetadata: objectMetadataEntity,
+      properties: {
+        before,
+      },
+    } satisfies ObjectRecordDeleteEvent<Entity>;
+  }
+
+  if (action === 'destroyed') {
+    return {
+      recordId,
+      userId,
+      workspaceMemberId,
+      objectMetadata: objectMetadataEntity,
+      properties: {
+        before,
+      },
+    } satisfies ObjectRecordDestroyEvent<Entity>;
+  }
+
+  throw new Error(`Unknown action '${action}'`);
+};

packages/twenty-server/src/modules/workflow/workflow-builder/utils/generate-fake-object-record.ts

@@ -0,0 +1,11 @@
+import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
+import { generateFakeValue } from 'src/engine/utils/generate-fake-value';
+
+export const generateFakeObjectRecord = <Entity>(
+  objectMetadataEntity: ObjectMetadataEntity,
+): Entity =>
+  objectMetadataEntity.fields.reduce((acc, field) => {
+    acc[field.name] = generateFakeValue(field.type);
+
+    return acc;
+  }, {} as Entity);

packages/twenty-server/src/modules/workflow/workflow-builder/workflow-builder.service.ts

@@ -1,24 +1,26 @@
-import { InjectRepository } from '@nestjs/typeorm';
 import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
 
 import { join } from 'path';
 
 import { Repository } from 'typeorm';
 
+import { generateFakeObjectRecordEvent } from 'src/engine/core-modules/event-emitter/utils/generate-fake-object-record-event';
+import { INDEX_FILE_NAME } from 'src/engine/core-modules/serverless/drivers/constants/index-file-name';
+import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
 import { ServerlessFunctionService } from 'src/engine/metadata-modules/serverless-function/serverless-function.service';
 import { CodeIntrospectionService } from 'src/modules/code-introspection/code-introspection.service';
-import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
-import {
-  WorkflowTrigger,
-  WorkflowTriggerType,
-} from 'src/modules/workflow/workflow-trigger/types/workflow-trigger.type';
+import { generateFakeObjectRecord } from 'src/modules/workflow/workflow-builder/utils/generate-fake-object-record';
 import {
   WorkflowActionType,
   WorkflowStep,
 } from 'src/modules/workflow/workflow-executor/types/workflow-action.type';
+import { WorkflowSendEmailStepOutputSchema } from 'src/modules/workflow/workflow-executor/types/workflow-step-settings.type';
+import {
+  WorkflowTrigger,
+  WorkflowTriggerType,
+} from 'src/modules/workflow/workflow-trigger/types/workflow-trigger.type';
 import { isDefined } from 'src/utils/is-defined';
-import { generateFakeObjectRecordEvent } from 'src/engine/core-modules/event-emitter/utils/generate-fake-object-record-event';
-import { INDEX_FILE_NAME } from 'src/engine/core-modules/serverless/drivers/constants/index-file-name';
 
 @Injectable()
 export class WorkflowBuilderService {
@@ -35,77 +37,155 @@ export class WorkflowBuilderService {
   }: {
     step: WorkflowTrigger | WorkflowStep;
     workspaceId: string;
-  }) {
+  }): Promise<object> {
     const stepType = step.type;
 
     switch (stepType) {
       case WorkflowTriggerType.DATABASE_EVENT: {
-        const [nameSingular, action] = step.settings.eventName.split('.');
+        return await this.computeDatabaseEventTriggerOutputSchema({
+          eventName: step.settings.eventName,
+          workspaceId,
+          objectMetadataRepository: this.objectMetadataRepository,
+        });
+      }
+      case WorkflowTriggerType.MANUAL: {
+        const { objectType } = step.settings;
 
-        if (!['created', 'updated', 'deleted', 'destroyed'].includes(action)) {
+        if (!objectType) {
           return {};
         }
 
-        const objectMetadata =
-          await this.objectMetadataRepository.findOneOrFail({
-            where: {
-              nameSingular,
-              workspaceId,
-            },
-            relations: ['fields'],
-          });
-
-        if (!isDefined(objectMetadata)) {
-          return {};
-        }
-
-        return generateFakeObjectRecordEvent(
-          objectMetadata,
-          action as 'created' | 'updated' | 'deleted' | 'destroyed',
-        );
+        return await this.computeManualTriggerOutputSchema({
+          objectType,
+          workspaceId,
+          objectMetadataRepository: this.objectMetadataRepository,
+        });
       }
       case WorkflowActionType.SEND_EMAIL: {
-        return { success: true };
+        return this.computeSendEmailActionOutputSchema();
       }
       case WorkflowActionType.CODE: {
         const { serverlessFunctionId, serverlessFunctionVersion } =
           step.settings.input;
 
-        if (serverlessFunctionId === '') {
-          return {};
-        }
-
-        const sourceCode = (
-          await this.serverlessFunctionService.getServerlessFunctionSourceCode(
-            workspaceId,
-            serverlessFunctionId,
-            serverlessFunctionVersion,
-          )
-        )?.[join('src', INDEX_FILE_NAME)];
-
-        if (!isDefined(sourceCode)) {
-          return {};
-        }
-
-        const fakeFunctionInput =
-          this.codeIntrospectionService.generateInputData(sourceCode);
-
-        // handle the case when event parameter is destructured:
-        // (event: {param1: string; param2: number}) VS ({param1, param2}: {param1: string; param2: number})
-        const formattedInput = Object.values(fakeFunctionInput)[0];
-
-        const resultFromFakeInput =
-          await this.serverlessFunctionService.executeOneServerlessFunction(
-            serverlessFunctionId,
-            workspaceId,
-            formattedInput,
-            serverlessFunctionVersion,
-          );
-
-        return resultFromFakeInput.data ?? {};
+        return await this.computeCodeActionOutputSchema({
+          serverlessFunctionId,
+          serverlessFunctionVersion,
+          workspaceId,
+          serverlessFunctionService: this.serverlessFunctionService,
+          codeIntrospectionService: this.codeIntrospectionService,
+        });
       }
       default:
-        throw new Error(`Unknown type ${stepType}`);
+        return {};
     }
   }
+
+  private async computeDatabaseEventTriggerOutputSchema({
+    eventName,
+    workspaceId,
+    objectMetadataRepository,
+  }: {
+    eventName: string;
+    workspaceId: string;
+    objectMetadataRepository: Repository<ObjectMetadataEntity>;
+  }) {
+    const [nameSingular, action] = eventName.split('.');
+
+    if (!['created', 'updated', 'deleted', 'destroyed'].includes(action)) {
+      return {};
+    }
+
+    const objectMetadata = await objectMetadataRepository.findOneOrFail({
+      where: {
+        nameSingular,
+        workspaceId,
+      },
+      relations: ['fields'],
+    });
+
+    if (!isDefined(objectMetadata)) {
+      return {};
+    }
+
+    return generateFakeObjectRecordEvent(
+      objectMetadata,
+      action as 'created' | 'updated' | 'deleted' | 'destroyed',
+    );
+  }
+
+  private async computeManualTriggerOutputSchema<Entity>({
+    objectType,
+    workspaceId,
+    objectMetadataRepository,
+  }: {
+    objectType: string;
+    workspaceId: string;
+    objectMetadataRepository: Repository<ObjectMetadataEntity>;
+  }) {
+    const objectMetadata = await objectMetadataRepository.findOneOrFail({
+      where: {
+        nameSingular: objectType,
+        workspaceId,
+      },
+      relations: ['fields'],
+    });
+
+    if (!isDefined(objectMetadata)) {
+      return {};
+    }
+
+    return generateFakeObjectRecord<Entity>(objectMetadata);
+  }
+
+  private computeSendEmailActionOutputSchema(): WorkflowSendEmailStepOutputSchema {
+    return { success: true };
+  }
+
+  private async computeCodeActionOutputSchema({
+    serverlessFunctionId,
+    serverlessFunctionVersion,
+    workspaceId,
+    serverlessFunctionService,
+    codeIntrospectionService,
+  }: {
+    serverlessFunctionId: string;
+    serverlessFunctionVersion: string;
+    workspaceId: string;
+    serverlessFunctionService: ServerlessFunctionService;
+    codeIntrospectionService: CodeIntrospectionService;
+  }) {
+    if (serverlessFunctionId === '') {
+      return {};
+    }
+
+    const sourceCode = (
+      await serverlessFunctionService.getServerlessFunctionSourceCode(
+        workspaceId,
+        serverlessFunctionId,
+        serverlessFunctionVersion,
+      )
+    )?.[join('src', INDEX_FILE_NAME)];
+
+    if (!isDefined(sourceCode)) {
+      return {};
+    }
+
+    const fakeFunctionInput =
+      codeIntrospectionService.generateInputData(sourceCode);
+
+    // handle the case when event parameter is destructured:
+    // (event: {param1: string; param2: number}) VS ({param1, param2}: {param1: string; param2: number})
+    const formattedInput = Object.values(fakeFunctionInput)[0];
+
+    const resultFromFakeInput =
+      await serverlessFunctionService.executeOneServerlessFunction(
+        serverlessFunctionId,
+        workspaceId,
+        formattedInput,
+        serverlessFunctionVersion,
+      );
+
+    return resultFromFakeInput.data ?? {};
+  }
 }

packages/twenty-server/src/modules/workflow/workflow-executor/types/workflow-step-settings.type.ts

@@ -30,6 +30,10 @@ export type WorkflowSendEmailStepInput = {
   body?: string;
 };
 
+export type WorkflowSendEmailStepOutputSchema = {
+  success: boolean;
+};
+
 export type WorkflowSendEmailStepSettings = BaseWorkflowStepSettings & {
   input: WorkflowSendEmailStepInput;
 };