8726 workflow add a test button in workflow code step (#9016)

- add test button to workflow code step - add test tab to workflow code step https://github.com/user-attachments/assets/e180a827-7321-49a2-8026-88490c557da2 ![image](https://github.com/user-attachments/assets/cacbd756-de3f-4141-a84c-8e1853f6556b) ![image](https://github.com/user-attachments/assets/ee170d81-8a22-4178-bd6d-11a0e8c73365)
2024-12-13 11:16:29 +01:00
parent 07aaf0801c
commit b10d831371
95 changed files with 1537 additions and 1611 deletions
--- a/packages/twenty-server/src/engine/core-modules/graphql/utils/graphql-errors.util.ts
+++ b/packages/twenty-server/src/engine/core-modules/graphql/utils/graphql-errors.util.ts
@ -55,7 +55,7 @@ export class BaseGraphQLError extends GraphQLError {
    }

    if (extensions?.extensions) {
-      throw Error(
+      throw new Error(
        'Pass extensions directly as the third argument of the ApolloError constructor: `new ' +
          'ApolloError(message, code, {myExt: value})`, not `new ApolloError(message, code, ' +
          '{extensions: {myExt: value}})`',
--- a/packages/twenty-server/src/engine/core-modules/serverless/drivers/constants/base-typescript-project-input-schema.ts
+++ b/packages/twenty-server/src/engine/core-modules/serverless/drivers/constants/base-typescript-project-input-schema.ts
@ -0,0 +1,4 @@
+export const BASE_TYPESCRIPT_PROJECT_INPUT_SCHEMA = {
+  a: null,
+  b: null,
+};
--- a/packages/twenty-server/src/engine/core-modules/workflow/dtos/update-workflow-version-step-input.dto.ts
+++ b/packages/twenty-server/src/engine/core-modules/workflow/dtos/update-workflow-version-step-input.dto.ts
@ -17,11 +17,4 @@ export class UpdateWorkflowVersionStepInput {
    nullable: false,
  })
  step: WorkflowAction;
-
-  @Field(() => Boolean, {
-    description: 'Boolean to check if we need to update stepOutput',
-    nullable: true,
-    defaultValue: true,
-  })
-  shouldUpdateStepOutput: boolean;
 }
--- a/packages/twenty-server/src/engine/core-modules/workflow/resolvers/workflow-version-step.resolver.ts
+++ b/packages/twenty-server/src/engine/core-modules/workflow/resolvers/workflow-version-step.resolver.ts
@ -37,17 +37,12 @@ export class WorkflowVersionStepResolver {
  async updateWorkflowVersionStep(
    @AuthWorkspace() { id: workspaceId }: Workspace,
    @Args('input')
-    {
-      step,
-      workflowVersionId,
-      shouldUpdateStepOutput,
-    }: UpdateWorkflowVersionStepInput,
+    { step, workflowVersionId }: UpdateWorkflowVersionStepInput,
  ): Promise<WorkflowActionDTO> {
    return this.workflowVersionStepWorkspaceService.updateWorkflowVersionStep({
      workspaceId,
      workflowVersionId,
      step,
-      shouldUpdateStepOutput,
    });
  }

--- a/packages/twenty-server/src/engine/metadata-modules/serverless-function/dtos/serverless-function.dto.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/serverless-function/dtos/serverless-function.dto.ts
@ -22,7 +22,7 @@ import GraphQLJSON from 'graphql-type-json';

 import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
 import { ServerlessFunctionSyncStatus } from 'src/engine/metadata-modules/serverless-function/serverless-function.entity';
-import { InputSchema } from 'src/modules/code-introspection/types/input-schema.type';
+import { InputSchema } from 'src/modules/workflow/workflow-builder/types/input-schema.type';

 registerEnumType(ServerlessFunctionSyncStatus, {
  name: 'ServerlessFunctionSyncStatus',
--- a/packages/twenty-server/src/engine/metadata-modules/serverless-function/serverless-function.entity.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/serverless-function/serverless-function.entity.ts
@ -6,7 +6,7 @@ import {
  UpdateDateColumn,
 } from 'typeorm';

-import { InputSchema } from 'src/modules/code-introspection/types/input-schema.type';
+import { InputSchema } from 'src/modules/workflow/workflow-builder/types/input-schema.type';

 export enum ServerlessFunctionSyncStatus {
  NOT_READY = 'NOT_READY',
--- a/packages/twenty-server/src/modules/code-introspection/tests/code-introspection.service.spec.ts
+++ b/packages/twenty-server/src/modules/code-introspection/tests/code-introspection.service.spec.ts
@ -1,138 +0,0 @@
-import { Test, TestingModule } from '@nestjs/testing';
-
-import { CodeIntrospectionService } from 'src/modules/code-introspection/code-introspection.service';
-
-describe('CodeIntrospectionService', () => {
-  let service: CodeIntrospectionService;
-
-  beforeEach(async () => {
-    const module: TestingModule = await Test.createTestingModule({
-      providers: [CodeIntrospectionService],
-    }).compile();
-
-    service = module.get<CodeIntrospectionService>(CodeIntrospectionService);
-  });
-
-  it('should be defined', () => {
-    expect(service).toBeDefined();
-  });
-
-  describe('getFunctionInputSchema', () => {
-    it('should analyze a simple function correctly', () => {
-      const fileContent = `
-        function testFunction(param1: string, param2: number): void {
-          return;
-        }
-      `;
-      const result = service.getFunctionInputSchema(fileContent);
-
-      expect(result).toEqual({
-        param1: { type: 'string' },
-        param2: { type: 'number' },
-      });
-    });
-
-    it('should analyze a arrow function correctly', () => {
-      const fileContent = `
-        export const main = async (
-          param1: string,
-          param2: number,
-        ): Promise<object> => {
-          return params;
-        };
-      `;
-      const result = service.getFunctionInputSchema(fileContent);
-
-      expect(result).toEqual({
-        param1: { type: 'string' },
-        param2: { type: 'number' },
-      });
-    });
-
-    it('should analyze a complex function correctly', () => {
-      const fileContent = `
-        function testFunction(
-          params: {
-            param1: string;
-            param2: number;
-            param3: boolean;
-            param4: object;
-            param5: { subParam1: string };
-            param6: "my" | "enum";
-            param7: string[];
-          }
-        ): void {
-          return
-        }
-      `;
-      const result = service.getFunctionInputSchema(fileContent);
-
-      expect(result).toEqual({
-        params: {
-          type: 'object',
-          properties: {
-            param1: { type: 'string' },
-            param2: { type: 'number' },
-            param3: { type: 'boolean' },
-            param4: { type: 'object' },
-            param5: {
-              type: 'object',
-              properties: {
-                subParam1: { type: 'string' },
-              },
-            },
-            param6: { type: 'string', enum: ['my', 'enum'] },
-            param7: { type: 'array', items: { type: 'string' } },
-          },
-        },
-      });
-    });
-  });
-
-  describe('generateInputData', () => {
-    it('should generate fake data for simple function', () => {
-      const fileContent = `
-        function testFunction(param1: string, param2: number): void {
-          return;
-        }
-      `;
-      const inputSchema = service.getFunctionInputSchema(fileContent);
-      const result = service.generateInputData(inputSchema);
-
-      expect(result).toEqual({ param1: 'generated-string-value', param2: 1 });
-    });
-
-    it('should generate fake data for complex function', () => {
-      const fileContent = `
-        function testFunction(
-          params: {
-            param1: string;
-            param2: number;
-            param3: boolean;
-            param4: object;
-            param5: { subParam1: string };
-            param6: "my" | "enum";
-            param7: string[];
-          }
-        ): void {
-          return
-        }
-      `;
-
-      const inputSchema = service.getFunctionInputSchema(fileContent);
-      const result = service.generateInputData(inputSchema);
-
-      expect(result).toEqual({
-        params: {
-          param1: 'generated-string-value',
-          param2: 1,
-          param3: true,
-          param4: {},
-          param5: { subParam1: 'generated-string-value' },
-          param6: 'my',
-          param7: ['generated-string-value'],
-        },
-      });
-    });
-  });
-});
--- a/packages/twenty-server/src/modules/code-introspection/code-introspection.exception.ts
+++ b/packages/twenty-server/src/modules/code-introspection/code-introspection.exception.ts
@ -1,12 +0,0 @@
-import { CustomException } from 'src/utils/custom-exception';
-
-export class CodeIntrospectionException extends CustomException {
-  code: CodeIntrospectionExceptionCode;
-  constructor(message: string, code: CodeIntrospectionExceptionCode) {
-    super(message, code);
-  }
-}
-
-export enum CodeIntrospectionExceptionCode {
-  ONLY_ONE_FUNCTION_ALLOWED = 'ONLY_ONE_FUNCTION_ALLOWED',
-}
--- a/packages/twenty-server/src/modules/code-introspection/code-introspection.module.ts
+++ b/packages/twenty-server/src/modules/code-introspection/code-introspection.module.ts
@ -1,9 +0,0 @@
-import { Module } from '@nestjs/common';
-
-import { CodeIntrospectionService } from 'src/modules/code-introspection/code-introspection.service';
-
-@Module({
-  providers: [CodeIntrospectionService],
-  exports: [CodeIntrospectionService],
-})
-export class CodeIntrospectionModule {}
--- a/packages/twenty-server/src/modules/code-introspection/code-introspection.service.ts
+++ b/packages/twenty-server/src/modules/code-introspection/code-introspection.service.ts
@ -1,157 +0,0 @@
-import { Injectable } from '@nestjs/common';
-
-import {
-  ArrayTypeNode,
-  createSourceFile,
-  LiteralTypeNode,
-  PropertySignature,
-  ScriptTarget,
-  StringLiteral,
-  SyntaxKind,
-  TypeNode,
-  UnionTypeNode,
-  VariableStatement,
-  ArrowFunction,
-  FunctionDeclaration,
-} from 'typescript';
-
-import { generateFakeValue } from 'src/engine/utils/generate-fake-value';
-import { isDefined } from 'src/utils/is-defined';
-import {
-  InputSchema,
-  InputSchemaProperty,
-} from 'src/modules/code-introspection/types/input-schema.type';
-
-@Injectable()
-export class CodeIntrospectionService {
-  public generateInputData(inputSchema: InputSchema, setNullValue = false) {
-    return Object.entries(inputSchema).reduce((acc, [key, value]) => {
-      if (isDefined(value.enum)) {
-        acc[key] = value.enum?.[0];
-      } else if (['string', 'number', 'boolean'].includes(value.type)) {
-        acc[key] = setNullValue ? null : generateFakeValue(value.type);
-      } else if (value.type === 'object') {
-        acc[key] = isDefined(value.properties)
-          ? this.generateInputData(value.properties, setNullValue)
-          : {};
-      } else if (value.type === 'array' && isDefined(value.items)) {
-        acc[key] = [generateFakeValue(value.items.type)];
-      }
-
-      return acc;
-    }, {});
-  }
-
-  public getFunctionInputSchema(fileContent: string): InputSchema {
-    const sourceFile = createSourceFile(
-      'temp.ts',
-      fileContent,
-      ScriptTarget.ESNext,
-      true,
-    );
-
-    const schema: InputSchema = {};
-
-    sourceFile.forEachChild((node) => {
-      if (node.kind === SyntaxKind.FunctionDeclaration) {
-        const funcNode = node as FunctionDeclaration;
-        const params = funcNode.parameters;
-
-        params.forEach((param) => {
-          const paramName = param.name.getText();
-          const typeNode = param.type;
-
-          if (typeNode) {
-            schema[paramName] = this.getTypeString(typeNode);
-          } else {
-            schema[paramName] = { type: 'unknown' };
-          }
-        });
-      } else if (node.kind === SyntaxKind.VariableStatement) {
-        const varStatement = node as VariableStatement;
-
-        varStatement.declarationList.declarations.forEach((declaration) => {
-          if (
-            declaration.initializer &&
-            declaration.initializer.kind === SyntaxKind.ArrowFunction
-          ) {
-            const arrowFunction = declaration.initializer as ArrowFunction;
-            const params = arrowFunction.parameters;
-
-            params.forEach((param: any) => {
-              const paramName = param.name.text;
-              const typeNode = param.type;
-
-              if (typeNode) {
-                schema[paramName] = this.getTypeString(typeNode);
-              } else {
-                schema[paramName] = { type: 'unknown' };
-              }
-            });
-          }
-        });
-      }
-    });
-
-    return schema;
-  }
-
-  private getTypeString(typeNode: TypeNode): InputSchemaProperty {
-    switch (typeNode.kind) {
-      case SyntaxKind.NumberKeyword:
-        return { type: 'number' };
-      case SyntaxKind.StringKeyword:
-        return { type: 'string' };
-      case SyntaxKind.BooleanKeyword:
-        return { type: 'boolean' };
-      case SyntaxKind.ArrayType:
-        return {
-          type: 'array',
-          items: this.getTypeString((typeNode as ArrayTypeNode).elementType),
-        };
-      case SyntaxKind.ObjectKeyword:
-        return { type: 'object' };
-      case SyntaxKind.TypeLiteral: {
-        const properties: InputSchema = {};
-
-        (typeNode as any).members.forEach((member: PropertySignature) => {
-          if (member.name && member.type) {
-            const memberName = (member.name as any).text;
-
-            properties[memberName] = this.getTypeString(member.type);
-          }
-        });
-
-        return { type: 'object', properties };
-      }
-      case SyntaxKind.UnionType: {
-        const unionNode = typeNode as UnionTypeNode;
-        const enumValues: string[] = [];
-
-        let isEnum = true;
-
-        unionNode.types.forEach((subType) => {
-          if (subType.kind === SyntaxKind.LiteralType) {
-            const literal = (subType as LiteralTypeNode).literal;
-
-            if (literal.kind === SyntaxKind.StringLiteral) {
-              enumValues.push((literal as StringLiteral).text);
-            } else {
-              isEnum = false;
-            }
-          } else {
-            isEnum = false;
-          }
-        });
-
-        if (isEnum) {
-          return { type: 'string', enum: enumValues };
-        }
-
-        return { type: 'unknown' };
-      }
-      default:
-        return { type: 'unknown' };
-    }
-  }
-}
--- a/packages/twenty-server/src/modules/workflow/common/workflow-common.module.ts
+++ b/packages/twenty-server/src/modules/workflow/common/workflow-common.module.ts
@ -9,7 +9,6 @@ import { WorkflowVersionStepWorkspaceService } from 'src/modules/workflow/common
 import { WorkflowBuilderModule } from 'src/modules/workflow/workflow-builder/workflow-builder.module';
 import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
 import { ServerlessFunctionModule } from 'src/engine/metadata-modules/serverless-function/serverless-function.module';
-import { CodeIntrospectionModule } from 'src/modules/code-introspection/code-introspection.module';

@Module({
  imports: [
@ -17,7 +16,6 @@ import { CodeIntrospectionModule } from 'src/modules/code-introspection/code-int
    WorkflowCommandModule,
    WorkflowBuilderModule,
    ServerlessFunctionModule,
-    CodeIntrospectionModule,
    NestjsQueryTypeOrmModule.forFeature([ObjectMetadataEntity], 'metadata'),
  ],
  providers: [
--- a/packages/twenty-server/src/modules/workflow/common/workspace-services/workflow-version-step.workspace-service.ts
+++ b/packages/twenty-server/src/modules/workflow/common/workspace-services/workflow-version-step.workspace-service.ts
@ -1,17 +1,13 @@
 import { Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';

-import { join } from 'path';
-
 import { Repository } from 'typeorm';
 import { v4 } from 'uuid';

-import { INDEX_FILE_NAME } from 'src/engine/core-modules/serverless/drivers/constants/index-file-name';
 import { WorkflowActionDTO } from 'src/engine/core-modules/workflow/dtos/workflow-step.dto';
 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 { TwentyORMManager } from 'src/engine/twenty-orm/twenty-orm.manager';
-import { CodeIntrospectionService } from 'src/modules/code-introspection/code-introspection.service';
 import {
  WorkflowVersionStepException,
  WorkflowVersionStepExceptionCode,
@ -24,6 +20,7 @@ import {
  WorkflowActionType,
 } from 'src/modules/workflow/workflow-executor/workflow-actions/types/workflow-action.type';
 import { isDefined } from 'src/utils/is-defined';
+import { BASE_TYPESCRIPT_PROJECT_INPUT_SCHEMA } from 'src/engine/core-modules/serverless/drivers/constants/base-typescript-project-input-schema';

 const TRIGGER_STEP_ID = 'trigger';

@ -46,7 +43,6 @@ export class WorkflowVersionStepWorkspaceService {
    private readonly twentyORMManager: TwentyORMManager,
    private readonly workflowBuilderWorkspaceService: WorkflowBuilderWorkspaceService,
    private readonly serverlessFunctionService: ServerlessFunctionService,
-    private readonly codeIntrospectionService: CodeIntrospectionService,
    @InjectRepository(ObjectMetadataEntity, 'metadata')
    private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
  ) {}
@ -78,21 +74,6 @@ export class WorkflowVersionStepWorkspaceService {
          );
        }

-        const sourceCode = (
-          await this.serverlessFunctionService.getServerlessFunctionSourceCode(
-            workspaceId,
-            newServerlessFunction.id,
-            'draft',
-          )
-        )?.[join('src', INDEX_FILE_NAME)];
-
-        const inputSchema = isDefined(sourceCode)
-          ? this.codeIntrospectionService.getFunctionInputSchema(sourceCode)
-          : {};
-
-        const serverlessFunctionInput =
-          this.codeIntrospectionService.generateInputData(inputSchema, true);
-
        return {
          id: newStepId,
          name: 'Code - Serverless Function',
@ -103,7 +84,7 @@ export class WorkflowVersionStepWorkspaceService {
            input: {
              serverlessFunctionId: newServerlessFunction.id,
              serverlessFunctionVersion: 'draft',
-              serverlessFunctionInput,
+              serverlessFunctionInput: BASE_TYPESCRIPT_PROJECT_INPUT_SCHEMA,
            },
          },
        };
@ -201,6 +182,11 @@ export class WorkflowVersionStepWorkspaceService {
    step: WorkflowAction;
    workspaceId: string;
  }): Promise<WorkflowAction> {
+    // We don't enrich on the fly for code workflow action. OutputSchema is computed and updated when testing the serverless function
+    if (step.type === WorkflowActionType.CODE) {
+      return step;
+    }
+
    const result = { ...step };
    const outputSchema =
      await this.workflowBuilderWorkspaceService.computeStepOutputSchema({
@ -262,12 +248,10 @@ export class WorkflowVersionStepWorkspaceService {
    workspaceId,
    workflowVersionId,
    step,
-    shouldUpdateStepOutput,
  }: {
    workspaceId: string;
    workflowVersionId: string;
    step: WorkflowAction;
-    shouldUpdateStepOutput: boolean;
  }): Promise<WorkflowAction> {
    const workflowVersionRepository =
      await this.twentyORMManager.getRepository<WorkflowVersionWorkspaceEntity>(
@ -294,12 +278,10 @@ export class WorkflowVersionStepWorkspaceService {
      );
    }

-    const enrichedNewStep = shouldUpdateStepOutput
-      ? await this.enrichOutputSchema({
-          step,
-          workspaceId,
-        })
-      : step;
+    const enrichedNewStep = await this.enrichOutputSchema({
+      step,
+      workspaceId,
+    });

    const updatedSteps = workflowVersion.steps.map((existingStep) => {
      if (existingStep.id === step.id) {
--- a/packages/twenty-server/src/modules/workflow/workflow-builder/types/input-schema.type.ts
+++ b/packages/twenty-server/src/modules/workflow/workflow-builder/types/input-schema.type.ts
@ -13,9 +13,11 @@ export type InputSchemaProperty = {
  type: InputSchemaPropertyType;
  enum?: string[];
  items?: InputSchemaProperty; // used to describe array type elements
-  properties?: InputSchema; // used to describe object type elements
+  properties?: Properties; // used to describe object type elements
 };

-export type InputSchema = {
+type Properties = {
  [name: string]: InputSchemaProperty;
 };
+
+export type InputSchema = InputSchemaProperty[];
--- a/packages/twenty-server/src/modules/workflow/workflow-builder/types/output-schema.type.ts
+++ b/packages/twenty-server/src/modules/workflow/workflow-builder/types/output-schema.type.ts
@ -1,9 +1,9 @@
-import { InputSchemaPropertyType } from 'src/modules/code-introspection/types/input-schema.type';
+import { InputSchemaPropertyType } from 'src/modules/workflow/workflow-builder/types/input-schema.type';

 export type Leaf = {
  isLeaf: true;
-  icon?: string;
  type?: InputSchemaPropertyType;
+  icon?: string;
  label?: string;
  value: any;
 };
--- a/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-builder.module.ts
+++ b/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-builder.module.ts
@ -3,14 +3,12 @@ import { TypeOrmModule } from '@nestjs/typeorm';

 import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
 import { ServerlessFunctionModule } from 'src/engine/metadata-modules/serverless-function/serverless-function.module';
-import { CodeIntrospectionModule } from 'src/modules/code-introspection/code-introspection.module';
 import { WorkflowBuilderWorkspaceService } from 'src/modules/workflow/workflow-builder/workflow-builder.workspace-service';

@Module({
  imports: [
    TypeOrmModule.forFeature([ObjectMetadataEntity], 'metadata'),
    ServerlessFunctionModule,
-    CodeIntrospectionModule,
  ],
  providers: [WorkflowBuilderWorkspaceService],
  exports: [WorkflowBuilderWorkspaceService],
--- a/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-builder.workspace-service.ts
+++ b/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-builder.workspace-service.ts
@ -1,23 +1,14 @@
 import { Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';

-import { join } from 'path';
-
 import { Repository } from 'typeorm';

 import { DatabaseEventAction } from 'src/engine/api/graphql/graphql-query-runner/enums/database-event-action';
 import { checkStringIsDatabaseEventAction } from 'src/engine/api/graphql/graphql-query-runner/utils/check-string-is-database-event-action';
-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 { generateFakeValue } from 'src/engine/utils/generate-fake-value';
-import { CodeIntrospectionService } from 'src/modules/code-introspection/code-introspection.service';
-import { InputSchemaPropertyType } from 'src/modules/code-introspection/types/input-schema.type';
-import {
-  Leaf,
-  Node,
-  OutputSchema,
-} from 'src/modules/workflow/workflow-builder/types/output-schema.type';
+import { OutputSchema } from 'src/modules/workflow/workflow-builder/types/output-schema.type';
 import { generateFakeObjectRecord } from 'src/modules/workflow/workflow-builder/utils/generate-fake-object-record';
 import { generateFakeObjectRecordEvent } from 'src/modules/workflow/workflow-builder/utils/generate-fake-object-record-event';
 import {
@ -34,7 +25,6 @@ import { isDefined } from 'src/utils/is-defined';
 export class WorkflowBuilderWorkspaceService {
  constructor(
    private readonly serverlessFunctionService: ServerlessFunctionService,
-    private readonly codeIntrospectionService: CodeIntrospectionService,
    @InjectRepository(ObjectMetadataEntity, 'metadata')
    private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
  ) {}
@ -72,18 +62,6 @@ export class WorkflowBuilderWorkspaceService {
      case WorkflowActionType.SEND_EMAIL: {
        return this.computeSendEmailActionOutputSchema();
      }
-      case WorkflowActionType.CODE: {
-        const { serverlessFunctionId, serverlessFunctionVersion } =
-          step.settings.input;
-
-        return this.computeCodeActionOutputSchema({
-          serverlessFunctionId,
-          serverlessFunctionVersion,
-          workspaceId,
-          serverlessFunctionService: this.serverlessFunctionService,
-          codeIntrospectionService: this.codeIntrospectionService,
-        });
-      }
      case WorkflowActionType.CREATE_RECORD:
      case WorkflowActionType.UPDATE_RECORD:
      case WorkflowActionType.DELETE_RECORD:
@ -98,6 +76,7 @@ export class WorkflowBuilderWorkspaceService {
          workspaceId,
          objectMetadataRepository: this.objectMetadataRepository,
        });
+      case WorkflowActionType.CODE: // StepOutput schema is computed on serverlessFunction draft execution
      default:
        return {};
    }
@ -194,63 +173,4 @@ export class WorkflowBuilderWorkspaceService {
  private computeSendEmailActionOutputSchema(): OutputSchema {
    return { success: { isLeaf: true, type: 'boolean', value: true } };
  }
-
-  private async computeCodeActionOutputSchema({
-    serverlessFunctionId,
-    serverlessFunctionVersion,
-    workspaceId,
-    serverlessFunctionService,
-    codeIntrospectionService,
-  }: {
-    serverlessFunctionId: string;
-    serverlessFunctionVersion: string;
-    workspaceId: string;
-    serverlessFunctionService: ServerlessFunctionService;
-    codeIntrospectionService: CodeIntrospectionService;
-  }): Promise<OutputSchema> {
-    if (serverlessFunctionId === '') {
-      return {};
-    }
-
-    const sourceCode = (
-      await serverlessFunctionService.getServerlessFunctionSourceCode(
-        workspaceId,
-        serverlessFunctionId,
-        serverlessFunctionVersion,
-      )
-    )?.[join('src', INDEX_FILE_NAME)];
-
-    if (!isDefined(sourceCode)) {
-      return {};
-    }
-
-    const inputSchema =
-      codeIntrospectionService.getFunctionInputSchema(sourceCode);
-
-    const fakeFunctionInput =
-      codeIntrospectionService.generateInputData(inputSchema);
-
-    const resultFromFakeInput =
-      await serverlessFunctionService.executeOneServerlessFunction(
-        serverlessFunctionId,
-        workspaceId,
-        Object.values(fakeFunctionInput)?.[0] || {},
-        serverlessFunctionVersion,
-      );
-
-    return resultFromFakeInput.data
-      ? Object.entries(resultFromFakeInput.data).reduce(
-          (acc: Record<string, Leaf | Node>, [key, value]) => {
-            acc[key] = {
-              isLeaf: true,
-              value,
-              type: typeof value as InputSchemaPropertyType,
-            };
-
-            return acc;
-          },
-          {},
-        )
-      : {};
-  }
 }
--- a/packages/twenty-server/src/modules/workflow/workflow-executor/workflow-actions/code/code.workflow-action.ts
+++ b/packages/twenty-server/src/modules/workflow/workflow-executor/workflow-actions/code/code.workflow-action.ts
@ -35,7 +35,7 @@ export class CodeWorkflowAction implements WorkflowAction {
        await this.serverlessFunctionService.executeOneServerlessFunction(
          workflowActionInput.serverlessFunctionId,
          workspaceId,
-          Object.values(workflowActionInput.serverlessFunctionInput)?.[0] || {},
+          workflowActionInput.serverlessFunctionInput,
          workflowActionInput.serverlessFunctionVersion,
        );