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/dtos/create-logic-function.input.ts

@@ -38,6 +38,12 @@ export class CreateLogicFunctionInput {
   @HideField()
   universalIdentifier?: string;
 
+  @HideField()
+  id?: string;
+
+  @HideField()
+  checksum?: string;
+
   @Field(() => graphqlTypeJson, { nullable: true })
   @IsObject()
   @IsOptional()

packages/twenty-server/src/engine/metadata-modules/logic-function/dtos/execute-logic-function.input.ts

@@ -1,12 +1,18 @@
 import { Field, InputType } from '@nestjs/graphql';
 
-import { IsNotEmpty, IsObject, IsUUID } from 'class-validator';
+import {
+  IsBoolean,
+  IsNotEmpty,
+  IsObject,
+  IsOptional,
+  IsUUID,
+} from 'class-validator';
 import graphqlTypeJson from 'graphql-type-json';
 
 import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
 
 @InputType()
-export class ExecuteLogicFunctionInput {
+export class ExecuteOneLogicFunctionInput {
   @Field(() => UUIDScalarType, {
     description: 'Id of the logic function to execute',
   })
@@ -19,4 +25,12 @@ export class ExecuteLogicFunctionInput {
   })
   @IsObject()
   payload: JSON;
+
+  @Field(() => Boolean, {
+    description: 'Force rebuild from source before executing',
+    nullable: true,
+  })
+  @IsOptional()
+  @IsBoolean()
+  forceRebuild?: boolean;
 }

packages/twenty-server/src/engine/metadata-modules/logic-function/dtos/update-logic-function-source.input.ts

@@ -0,0 +1,25 @@
+import { Field, InputType } from '@nestjs/graphql';
+
+import { IsNotEmpty, IsObject, IsUUID } from 'class-validator';
+import graphqlTypeJson from 'graphql-type-json';
+
+import type { Sources } from 'twenty-shared/types';
+
+import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
+
+@InputType()
+export class UpdateLogicFunctionSourceInput {
+  @Field(() => UUIDScalarType, {
+    description: 'The id of the logic function.',
+  })
+  @IsNotEmpty()
+  @IsUUID()
+  id!: string;
+
+  @Field(() => graphqlTypeJson, {
+    description:
+      'The source code (Sources) to write. Only updates source files.',
+  })
+  @IsObject()
+  code!: Sources;
+}

packages/twenty-server/src/engine/metadata-modules/logic-function/dtos/update-logic-function.input.ts

@@ -38,9 +38,10 @@ class UpdateLogicFunctionInputUpdates {
   @IsOptional()
   timeoutSeconds?: number;
 
-  @Field(() => graphqlTypeJson)
+  @Field(() => graphqlTypeJson, { nullable: true })
   @IsObject()
-  code: Sources;
+  @IsOptional()
+  code?: Sources;
 
   @IsString()
   @Field({ nullable: true })

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

@@ -14,6 +14,7 @@ export enum LogicFunctionExceptionCode {
   LOGIC_FUNCTION_CREATE_FAILED = 'LOGIC_FUNCTION_CREATE_FAILED',
   LOGIC_FUNCTION_EXECUTION_TIMEOUT = 'LOGIC_FUNCTION_EXECUTION_TIMEOUT',
   LOGIC_FUNCTION_DISABLED = 'LOGIC_FUNCTION_DISABLED',
+  LOGIC_FUNCTION_INVALID_SEED_PROJECT = 'LOGIC_FUNCTION_INVALID_SEED_PROJECT',
 }
 
 const getLogicFunctionExceptionUserFriendlyMessage = (
@@ -38,6 +39,8 @@ const getLogicFunctionExceptionUserFriendlyMessage = (
       return msg`Function execution timed out.`;
     case LogicFunctionExceptionCode.LOGIC_FUNCTION_DISABLED:
       return msg`Logic function execution is disabled.`;
+    case LogicFunctionExceptionCode.LOGIC_FUNCTION_INVALID_SEED_PROJECT:
+      return msg`Invalid seed project configuration.`;
     default:
       assertUnreachable(code);
   }

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

@@ -12,6 +12,7 @@ import { FeatureFlagModule } from 'src/engine/core-modules/feature-flag/feature-
 import { FileUploadModule } from 'src/engine/core-modules/file/file-upload/file-upload.module';
 import { FileModule } from 'src/engine/core-modules/file/file.module';
 import { LogicFunctionExecutorModule } from 'src/engine/core-modules/logic-function/logic-function-executor/logic-function-executor.module';
+import { LogicFunctionSourceBuilderModule } from 'src/engine/core-modules/logic-function/logic-function-source-builder/logic-function-source-builder.module';
 import { SecretEncryptionModule } from 'src/engine/core-modules/secret-encryption/secret-encryption.module';
 import { ThrottlerModule } from 'src/engine/core-modules/throttler/throttler.module';
 import { WorkspaceManyOrAllFlatEntityMapsCacheModule } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.module';
@@ -40,6 +41,7 @@ import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspace
     WorkspaceMigrationModule,
     LogicFunctionLayerModule,
     LogicFunctionExecutorModule,
+    LogicFunctionSourceBuilderModule,
     SubscriptionsModule,
     WorkspaceCacheModule,
     TokenModule,

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 },

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

@@ -1,12 +1,11 @@
 import { Injectable } from '@nestjs/common';
 
-import { FileFolder } from 'twenty-shared/types';
 import { isDefined } from 'twenty-shared/utils';
 
 import { ApplicationService } from 'src/engine/core-modules/application/services/application.service';
 import { type FlatApplication } from 'src/engine/core-modules/application/types/flat-application.type';
 import { FileStorageService } from 'src/engine/core-modules/file-storage/file-storage.service';
-import { getLogicFunctionBaseFolderPath } from 'src/engine/core-modules/logic-function/logic-function-build/utils/get-logic-function-base-folder-path.util';
+import { LogicFunctionSourceBuilderService } from 'src/engine/core-modules/logic-function/logic-function-source-builder/logic-function-source-builder.service';
 import { WorkspaceManyOrAllFlatEntityMapsCacheService } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.service';
 import { findFlatEntityByIdInFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps-or-throw.util';
 import { findFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps.util';
@@ -32,6 +31,7 @@ export class LogicFunctionService {
     private readonly applicationService: ApplicationService,
     private readonly workspaceCacheService: WorkspaceCacheService,
     private readonly fileStorageService: FileStorageService,
+    private readonly logicFunctionSourceBuilderService: LogicFunctionSourceBuilderService,
   ) {}
 
   async createOne({
@@ -52,6 +52,7 @@ export class LogicFunctionService {
         )
       ).workspaceCustomFlatApplication;
 
+    // Generate flat logic function to get the ID
     const flatLogicFunctionToCreate =
       fromCreateLogicFunctionInputToFlatLogicFunction({
         createLogicFunctionInput: input,
@@ -59,6 +60,21 @@ export class LogicFunctionService {
         ownerFlatApplication: resolvedOwnerFlatApplication,
       });
 
+    // Seed the source files (uses provided code or default seed project)
+    const { sourceHandlerPath, builtHandlerPath, checksum } =
+      await this.logicFunctionSourceBuilderService.seedSourceFiles({
+        logicFunctionId: flatLogicFunctionToCreate.id,
+        workspaceId,
+        applicationUniversalIdentifier:
+          resolvedOwnerFlatApplication.universalIdentifier,
+        code: input.code,
+      });
+
+    // Update paths and checksum with actual values from seeding
+    flatLogicFunctionToCreate.sourceHandlerPath = sourceHandlerPath;
+    flatLogicFunctionToCreate.builtHandlerPath = builtHandlerPath;
+    flatLogicFunctionToCreate.checksum = checksum;
+
     const validateAndBuildResult =
       await this.workspaceMigrationValidateBuildAndRunService.validateBuildAndRunWorkspaceMigration(
         {
@@ -83,18 +99,7 @@ export class LogicFunctionService {
       );
     }
 
-    const { flatLogicFunctionMaps: recomputedExistingFlatLogicFunctionMaps } =
-      await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
-        {
-          workspaceId,
-          flatMapsKeys: ['flatLogicFunctionMaps'],
-        },
-      );
-
-    return findFlatEntityByIdInFlatEntityMapsOrThrow({
-      flatEntityId: flatLogicFunctionToCreate.id,
-      flatEntityMaps: recomputedExistingFlatLogicFunctionMaps,
-    });
+    return flatLogicFunctionToCreate;
   }
 
   async updateOne({
@@ -154,6 +159,74 @@ export class LogicFunctionService {
       );
     }
 
+    return this.getFlatLogicFunctionAfterUpdate(
+      optimisticallyUpdatedFlatLogicFunction.id,
+      workspaceId,
+    );
+  }
+
+  async updateChecksum({
+    id,
+    checksum,
+    workspaceId,
+  }: {
+    id: string;
+    checksum: string;
+    workspaceId: string;
+  }) {
+    const resolvedOwnerFlatApplication = (
+      await this.applicationService.findWorkspaceTwentyStandardAndCustomApplicationOrThrow(
+        { workspaceId },
+      )
+    ).workspaceCustomFlatApplication;
+
+    const { flatLogicFunctionMaps } =
+      await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
+        {
+          workspaceId,
+          flatMapsKeys: ['flatLogicFunctionMaps'],
+        },
+      );
+
+    const flatLogicFunction = findFlatLogicFunctionOrThrow({
+      id,
+      flatLogicFunctionMaps,
+    });
+
+    const optimisticallyUpdatedFlatLogicFunction = {
+      ...flatLogicFunction,
+      checksum,
+    };
+
+    const validateAndBuildResult =
+      await this.workspaceMigrationValidateBuildAndRunService.validateBuildAndRunWorkspaceMigration(
+        {
+          allFlatEntityOperationByMetadataName: {
+            logicFunction: {
+              flatEntityToCreate: [],
+              flatEntityToDelete: [],
+              flatEntityToUpdate: [optimisticallyUpdatedFlatLogicFunction],
+            },
+          },
+          workspaceId,
+          isSystemBuild: false,
+          applicationUniversalIdentifier:
+            resolvedOwnerFlatApplication.universalIdentifier,
+        },
+      );
+
+    if (isDefined(validateAndBuildResult)) {
+      throw new WorkspaceMigrationBuilderException(
+        validateAndBuildResult,
+        'Multiple validation errors occurred while updating logic function checksum',
+      );
+    }
+  }
+
+  private async getFlatLogicFunctionAfterUpdate(
+    id: string,
+    workspaceId: string,
+  ) {
     const { flatLogicFunctionMaps: recomputedExistingFlatLogicFunctionMaps } =
       await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
         {
@@ -163,7 +236,7 @@ export class LogicFunctionService {
       );
 
     return findFlatEntityByIdInFlatEntityMapsOrThrow({
-      flatEntityId: optimisticallyUpdatedFlatLogicFunction.id,
+      flatEntityId: id,
       flatEntityMaps: recomputedExistingFlatLogicFunctionMaps,
     });
   }
@@ -235,118 +308,4 @@ export class LogicFunctionService {
 
     return existingFlatLogicFunction;
   }
-
-  async duplicateLogicFunction({
-    id,
-    workspaceId,
-  }: {
-    id: string;
-    workspaceId: string;
-  }): Promise<FlatLogicFunction> {
-    return this.createLogicFunctionFromExistingLogicFunctionById({
-      id,
-      workspaceId,
-    });
-  }
-
-  async createLogicFunctionFromExistingLogicFunctionById({
-    id,
-    workspaceId,
-  }: {
-    id: string;
-    workspaceId: string;
-  }): Promise<FlatLogicFunction> {
-    const { flatLogicFunctionMaps } =
-      await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
-        {
-          workspaceId,
-          flatMapsKeys: ['flatLogicFunctionMaps'],
-        },
-      );
-
-    const existingLogicFunction = findFlatLogicFunctionOrThrow({
-      id,
-      flatLogicFunctionMaps,
-    });
-
-    return this.createLogicFunctionFromExistingLogicFunction({
-      existingLogicFunction,
-      workspaceId,
-    });
-  }
-
-  async createLogicFunctionFromExistingLogicFunction({
-    existingLogicFunction,
-    workspaceId,
-  }: {
-    existingLogicFunction: FlatLogicFunction;
-    workspaceId: string;
-  }): Promise<FlatLogicFunction> {
-    const { flatApplicationMaps } =
-      await this.workspaceCacheService.getOrRecompute(workspaceId, [
-        'flatApplicationMaps',
-      ]);
-
-    const existingApplicationUniversalIdentifier = isDefined(
-      existingLogicFunction.applicationId,
-    )
-      ? flatApplicationMaps.byId[existingLogicFunction.applicationId]
-          ?.universalIdentifier
-      : undefined;
-
-    if (!isDefined(existingApplicationUniversalIdentifier)) {
-      throw new LogicFunctionException(
-        `Application universal identifier not found for logic function ${existingLogicFunction.id}`,
-        LogicFunctionExceptionCode.LOGIC_FUNCTION_NOT_FOUND,
-      );
-    }
-
-    const newFlatLogicFunction = await this.createOne({
-      input: {
-        name: existingLogicFunction.name,
-        description: existingLogicFunction.description ?? undefined,
-        timeoutSeconds: existingLogicFunction.timeoutSeconds,
-      },
-      workspaceId,
-      applicationId: existingLogicFunction.applicationId ?? undefined,
-    });
-
-    const newApplicationUniversalIdentifier = isDefined(
-      newFlatLogicFunction.applicationId,
-    )
-      ? flatApplicationMaps.byId[newFlatLogicFunction.applicationId]
-          ?.universalIdentifier
-      : undefined;
-
-    if (!isDefined(newApplicationUniversalIdentifier)) {
-      throw new LogicFunctionException(
-        `Application universal identifier not found for logic function ${newFlatLogicFunction.id}`,
-        LogicFunctionExceptionCode.LOGIC_FUNCTION_NOT_FOUND,
-      );
-    }
-
-    const fromBaseFolderPath = getLogicFunctionBaseFolderPath(
-      existingLogicFunction.sourceHandlerPath,
-    );
-    const toBaseFolderPath = getLogicFunctionBaseFolderPath(
-      newFlatLogicFunction.sourceHandlerPath,
-    );
-
-    await this.fileStorageService.copy_v2({
-      from: {
-        workspaceId,
-        applicationUniversalIdentifier: existingApplicationUniversalIdentifier,
-        fileFolder: FileFolder.Source,
-        resourcePath: fromBaseFolderPath,
-      },
-      to: {
-        workspaceId,
-        applicationUniversalIdentifier: newApplicationUniversalIdentifier,
-        fileFolder: FileFolder.Source,
-        resourcePath: toBaseFolderPath,
-      },
-    });
-
-    return newFlatLogicFunction;
-  }
 }

packages/twenty-server/src/engine/metadata-modules/logic-function/utils/from-create-logic-function-input-to-flat-logic-function.util.ts

@@ -26,7 +26,7 @@ export const fromCreateLogicFunctionInputToFlatLogicFunction = ({
   workspaceId,
   ownerFlatApplication,
 }: FromCreateLogicFunctionInputToFlatLogicFunctionArgs): FlatLogicFunction => {
-  const id = v4();
+  const id = rawCreateLogicFunctionInput.id ?? v4();
   const currentDate = new Date();
 
   // Build full paths including the base folder
@@ -41,6 +41,14 @@ export const fromCreateLogicFunctionInputToFlatLogicFunction = ({
   const universalIdentifier =
     rawCreateLogicFunctionInput.universalIdentifier ?? v4();
 
+  const checksum = isDefined(rawCreateLogicFunctionInput.checksum)
+    ? rawCreateLogicFunctionInput.checksum
+    : rawCreateLogicFunctionInput?.code
+      ? logicFunctionCreateHash(
+          JSON.stringify(rawCreateLogicFunctionInput.code),
+        )
+      : null;
+
   return {
     id,
     cronTriggerSettings: null,
@@ -61,11 +69,7 @@ export const fromCreateLogicFunctionInputToFlatLogicFunction = ({
     timeoutSeconds: rawCreateLogicFunctionInput.timeoutSeconds ?? 300,
     workspaceId,
     code: rawCreateLogicFunctionInput?.code,
-    checksum: rawCreateLogicFunctionInput?.code
-      ? logicFunctionCreateHash(
-          JSON.stringify(rawCreateLogicFunctionInput.code),
-        )
-      : null,
+    checksum,
     // If no schema provided and no code provided, use default schema
     // (because the default template will be used)
     toolInputSchema: isDefined(rawCreateLogicFunctionInput?.toolInputSchema)

packages/twenty-server/src/engine/metadata-modules/logic-function/utils/from-update-logic-function-input-to-flat-logic-function-to-update-or-throw.util.ts

@@ -1,5 +1,6 @@
 import {
   extractAndSanitizeObjectStringFields,
+  isDefined,
   trimAndRemoveDuplicatedWhitespacesFromObjectStringProperties,
 } from 'twenty-shared/utils';
 
@@ -28,17 +29,19 @@ export const fromUpdateLogicFunctionInputToFlatLogicFunctionToUpdateOrThrow = ({
     id: logicFunctionToUpdateId,
     flatLogicFunctionMaps,
   });
+
+  const update = rawUpdateLogicFunctionInput.update;
   const updatedEditableFieldProperties = {
     ...extractAndSanitizeObjectStringFields(
       {
-        ...rawUpdateLogicFunctionInput.update,
-        checksum: logicFunctionCreateHash(
-          JSON.stringify(rawUpdateLogicFunctionInput.update.code),
-        ),
+        ...update,
+        ...(isDefined(update.code) && {
+          checksum: logicFunctionCreateHash(JSON.stringify(update.code)),
+        }),
       },
       FLAT_LOGIC_FUNCTION_EDITABLE_PROPERTIES,
     ),
-    code: rawUpdateLogicFunctionInput.update.code,
+    ...(isDefined(update.code) && { code: update.code }),
   };
 
   return mergeUpdateInExistingRecord({

packages/twenty-server/src/engine/metadata-modules/logic-function/utils/logic-function-graphql-api-exception-handler.utils.ts

@@ -27,6 +27,7 @@ export const logicFunctionGraphQLApiExceptionHandler = (error: any) => {
         throw new TimeoutError(error);
       case LogicFunctionExceptionCode.LOGIC_FUNCTION_CODE_UNCHANGED:
       case LogicFunctionExceptionCode.LOGIC_FUNCTION_CREATE_FAILED:
+      case LogicFunctionExceptionCode.LOGIC_FUNCTION_INVALID_SEED_PROJECT:
         throw error;
       case LogicFunctionExceptionCode.LOGIC_FUNCTION_DISABLED:
         throw new ForbiddenError(error);