Refactor workflow-logic-function-interaction (#17699)

# Refactor workflow–logic function interaction

## Why

Workflow code steps and standalone logic functions shared the same build
layer and DB layer, which blurred two use cases: code steps belong to a
workflow version; standalone functions are deployable units. That made
workflow code steps harder to own and evolve.

## Goal

Treat code steps as **workflow-owned**: build and run them in workflow
context, and expose workflow-scoped APIs so the editor can load, test,
and save code step source without going through the generic
logic-function layer.

packages/twenty-server/src/engine/metadata-modules/logic-function/logic-function.resolver.ts

@@ -5,9 +5,11 @@ import graphqlTypeJson from 'graphql-type-json';
 import { PermissionFlagType } from 'twenty-shared/constants';
 import { isDefined } from 'twenty-shared/utils';
 
+import { ApplicationService } from 'src/engine/core-modules/application/services/application.service';
 import { PreventNestToAutoLogGraphqlErrorsFilter } from 'src/engine/core-modules/graphql/filters/prevent-nest-to-auto-log-graphql-errors.filter';
 import { ResolverValidationPipe } from 'src/engine/core-modules/graphql/pipes/resolver-validation.pipe';
 import { LogicFunctionExecutorService } from 'src/engine/core-modules/logic-function/logic-function-executor/services/logic-function-executor.service';
+import { LogicFunctionSourceBuilderService } from 'src/engine/core-modules/logic-function/logic-function-source-builder/logic-function-source-builder.service';
 import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
 import { AuthWorkspace } from 'src/engine/decorators/auth/auth-workspace.decorator';
 import { FeatureFlagGuard } from 'src/engine/guards/feature-flag.guard';
@@ -15,14 +17,14 @@ import { SettingsPermissionGuard } from 'src/engine/guards/settings-permission.g
 import { WorkspaceAuthGuard } from 'src/engine/guards/workspace-auth.guard';
 import { WorkspaceManyOrAllFlatEntityMapsCacheService } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.service';
 import { CreateLogicFunctionInput } from 'src/engine/metadata-modules/logic-function/dtos/create-logic-function.input';
-import { ExecuteLogicFunctionInput } from 'src/engine/metadata-modules/logic-function/dtos/execute-logic-function.input';
+import { ExecuteOneLogicFunctionInput } from 'src/engine/metadata-modules/logic-function/dtos/execute-logic-function.input';
 import { GetLogicFunctionSourceCodeInput } from 'src/engine/metadata-modules/logic-function/dtos/get-logic-function-source-code.input';
 import { LogicFunctionExecutionResultDTO } from 'src/engine/metadata-modules/logic-function/dtos/logic-function-execution-result.dto';
 import { LogicFunctionIdInput } from 'src/engine/metadata-modules/logic-function/dtos/logic-function-id.input';
 import { LogicFunctionLogsDTO } from 'src/engine/metadata-modules/logic-function/dtos/logic-function-logs.dto';
 import { LogicFunctionLogsInput } from 'src/engine/metadata-modules/logic-function/dtos/logic-function-logs.input';
 import { LogicFunctionDTO } from 'src/engine/metadata-modules/logic-function/dtos/logic-function.dto';
-import { UpdateLogicFunctionInput } from 'src/engine/metadata-modules/logic-function/dtos/update-logic-function.input';
+import { UpdateLogicFunctionSourceInput } from 'src/engine/metadata-modules/logic-function/dtos/update-logic-function-source.input';
 import { LogicFunctionService } from 'src/engine/metadata-modules/logic-function/services/logic-function.service';
 import { FlatLogicFunction } from 'src/engine/metadata-modules/logic-function/types/flat-logic-function.type';
 import { findFlatLogicFunctionOrThrow } from 'src/engine/metadata-modules/logic-function/utils/find-flat-logic-function-or-throw.util';
@@ -43,10 +45,42 @@ export class LogicFunctionResolver {
   constructor(
     private readonly logicFunctionService: LogicFunctionService,
     private readonly logicFunctionExecutorService: LogicFunctionExecutorService,
+    private readonly logicFunctionSourceBuilderService: LogicFunctionSourceBuilderService,
+    private readonly applicationService: ApplicationService,
     private readonly subscriptionService: SubscriptionService,
     private readonly flatEntityMapsCacheService: WorkspaceManyOrAllFlatEntityMapsCacheService,
   ) {}
 
+  private async getLogicFunctionContext({
+    id,
+    workspaceId,
+  }: {
+    id: string;
+    workspaceId: string;
+  }) {
+    const [{ flatLogicFunctionMaps }, { workspaceCustomFlatApplication }] =
+      await Promise.all([
+        this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps({
+          workspaceId,
+          flatMapsKeys: ['flatLogicFunctionMaps'],
+        }),
+        this.applicationService.findWorkspaceTwentyStandardAndCustomApplicationOrThrow(
+          { workspaceId },
+        ),
+      ]);
+
+    const flatLogicFunction = findFlatLogicFunctionOrThrow({
+      id,
+      flatLogicFunctionMaps,
+    });
+
+    return {
+      flatLogicFunction,
+      applicationUniversalIdentifier:
+        workspaceCustomFlatApplication.universalIdentifier,
+    };
+  }
+
   @Query(() => LogicFunctionDTO)
   async findOneLogicFunction(
     @Args('input') { id }: LogicFunctionIdInput,
@@ -112,21 +146,6 @@ export class LogicFunctionResolver {
     }
   }
 
-  @Query(() => graphqlTypeJson, { nullable: true })
-  async getLogicFunctionSourceCode(
-    @Args('input') input: GetLogicFunctionSourceCodeInput,
-    @AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
-  ) {
-    try {
-      return await this.logicFunctionExecutorService.getLogicFunctionSourceCode(
-        workspaceId,
-        input.id,
-      );
-    } catch (error) {
-      return logicFunctionGraphQLApiExceptionHandler(error);
-    }
-  }
-
   @Mutation(() => LogicFunctionDTO)
   @UseGuards(SettingsPermissionGuard(PermissionFlagType.WORKFLOWS))
   async deleteOneLogicFunction(
@@ -147,28 +166,6 @@ export class LogicFunctionResolver {
     }
   }
 
-  @Mutation(() => LogicFunctionDTO)
-  @UseGuards(SettingsPermissionGuard(PermissionFlagType.WORKFLOWS))
-  async updateOneLogicFunction(
-    @Args('input')
-    input: UpdateLogicFunctionInput,
-    @AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
-  ): Promise<LogicFunctionDTO> {
-    try {
-      const flatLogicFunction = await this.logicFunctionService.updateOne({
-        id: input.id,
-        update: input.update,
-        workspaceId,
-      });
-
-      return fromFlatLogicFunctionToLogicFunctionDto({
-        flatLogicFunction,
-      });
-    } catch (error) {
-      return logicFunctionGraphQLApiExceptionHandler(error);
-    }
-  }
-
   @Mutation(() => LogicFunctionDTO)
   @UseGuards(SettingsPermissionGuard(PermissionFlagType.WORKFLOWS))
   async createOneLogicFunction(
@@ -193,22 +190,98 @@ export class LogicFunctionResolver {
   @Mutation(() => LogicFunctionExecutionResultDTO)
   @UseGuards(SettingsPermissionGuard(PermissionFlagType.WORKFLOWS))
   async executeOneLogicFunction(
-    @Args('input') input: ExecuteLogicFunctionInput,
+    @Args('input') { id, payload, forceRebuild }: ExecuteOneLogicFunctionInput,
+    @AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
+  ): Promise<LogicFunctionExecutionResultDTO> {
+    try {
+      if (forceRebuild) {
+        const { flatLogicFunction, applicationUniversalIdentifier } =
+          await this.getLogicFunctionContext({ id, workspaceId });
+
+        const { checksum } =
+          await this.logicFunctionSourceBuilderService.buildFromSource({
+            workspaceId,
+            applicationUniversalIdentifier,
+            sourceHandlerPath: flatLogicFunction.sourceHandlerPath,
+            builtHandlerPath: flatLogicFunction.builtHandlerPath,
+          });
+
+        await this.logicFunctionService.updateChecksum({
+          id,
+          checksum,
+          workspaceId,
+        });
+      }
+
+      const result =
+        await this.logicFunctionExecutorService.executeOneLogicFunction({
+          id,
+          workspaceId,
+          payload,
+        });
+
+      return {
+        data: result.data as LogicFunctionExecutionResultDTO['data'],
+        logs: result.logs,
+        duration: result.duration,
+        status: result.status,
+        error: result.error
+          ? {
+              errorType: result.error.errorType,
+              errorMessage: result.error.errorMessage,
+              stackTrace: Array.isArray(result.error.stackTrace)
+                ? result.error.stackTrace.join('\n')
+                : result.error.stackTrace,
+            }
+          : undefined,
+      };
+    } catch (error) {
+      return logicFunctionGraphQLApiExceptionHandler(error);
+    }
+  }
+
+  @Query(() => graphqlTypeJson, { nullable: true })
+  async getLogicFunctionSourceCode(
+    @Args('input') { id }: GetLogicFunctionSourceCodeInput,
     @AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
   ) {
     try {
-      const { id, payload } = input;
+      const { flatLogicFunction, applicationUniversalIdentifier } =
+        await this.getLogicFunctionContext({ id, workspaceId });
 
-      return await this.logicFunctionExecutorService.executeOneLogicFunction({
-        id,
+      return this.logicFunctionSourceBuilderService.getSourceCode({
         workspaceId,
-        payload,
+        applicationUniversalIdentifier,
+        sourceHandlerPath: flatLogicFunction.sourceHandlerPath,
       });
     } catch (error) {
       return logicFunctionGraphQLApiExceptionHandler(error);
     }
   }
 
+  @Mutation(() => Boolean)
+  @UseGuards(SettingsPermissionGuard(PermissionFlagType.WORKFLOWS))
+  async updateLogicFunctionSource(
+    @Args('input') { id, code }: UpdateLogicFunctionSourceInput,
+    @AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
+  ): Promise<boolean> {
+    try {
+      const { flatLogicFunction, applicationUniversalIdentifier } =
+        await this.getLogicFunctionContext({ id, workspaceId });
+
+      await this.logicFunctionSourceBuilderService.updateSourceFiles({
+        workspaceId,
+        applicationUniversalIdentifier,
+        sourceHandlerPath: flatLogicFunction.sourceHandlerPath,
+        code,
+      });
+
+      return true;
+    } catch (error) {
+      return logicFunctionGraphQLApiExceptionHandler(error);
+    }
+  }
+
   @Subscription(() => LogicFunctionLogsDTO, {
     filter: (
       payload: { logicFunctionLogs: LogicFunctionLogsDTO },