Rename serverlessFunction to logicFunction (#17494)

## Summary

Rename "Serverless Function" to "Logic Function" across the codebase for
clearer naming.

### Environment Variable Changes

| Old | New |
|-----|-----|
| `SERVERLESS_TYPE` | `LOGIC_FUNCTION_TYPE` |
| `SERVERLESS_LAMBDA_REGION` | `LOGIC_FUNCTION_LAMBDA_REGION` |
| `SERVERLESS_LAMBDA_ROLE` | `LOGIC_FUNCTION_LAMBDA_ROLE` |
| `SERVERLESS_LAMBDA_SUBHOSTING_URL` |
`LOGIC_FUNCTION_LAMBDA_SUBHOSTING_URL` |
| `SERVERLESS_LAMBDA_ACCESS_KEY_ID` |
`LOGIC_FUNCTION_LAMBDA_ACCESS_KEY_ID` |
| `SERVERLESS_LAMBDA_SECRET_ACCESS_KEY` |
`LOGIC_FUNCTION_LAMBDA_SECRET_ACCESS_KEY` |

### Breaking Changes

- Environment variables must be updated in production deployments
- Database migration renames `serverlessFunction` → `logicFunction`
tables

packages/twenty-server/src/engine/workspace-manager/workspace-manager.module.ts

@@ -14,7 +14,7 @@ import { PermissionsModule } from 'src/engine/metadata-modules/permissions/permi
 import { RoleTargetEntity } from 'src/engine/metadata-modules/role-target/role-target.entity';
 import { RoleEntity } from 'src/engine/metadata-modules/role/role.entity';
 import { RoleModule } from 'src/engine/metadata-modules/role/role.module';
-import { ServerlessFunctionEntity } from 'src/engine/metadata-modules/serverless-function/serverless-function.entity';
+import { LogicFunctionEntity } from 'src/engine/metadata-modules/logic-function/logic-function.entity';
 import { UserRoleModule } from 'src/engine/metadata-modules/user-role/user-role.module';
 import { WorkspaceDataSourceModule } from 'src/engine/workspace-datasource/workspace-datasource.module';
 import { DevSeederModule } from 'src/engine/workspace-manager/dev-seeder/dev-seeder.module';
@@ -43,7 +43,7 @@ import { WorkspaceManagerService } from './workspace-manager.service';
       FieldMetadataEntity,
       RoleTargetEntity,
       RoleEntity,
-      ServerlessFunctionEntity,
+      LogicFunctionEntity,
     ]),
   ],
   exports: [WorkspaceManagerService],

packages/twenty-server/src/engine/workspace-manager/workspace-migration/services/workspace-migration-build-orchestrator.service.ts

@@ -28,7 +28,7 @@ import { WorkspaceMigrationRoleTargetActionsBuilderService } from 'src/engine/wo
 import { WorkspaceMigrationRoleActionsBuilderService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/role/workspace-migration-role-actions-builder.service';
 import { WorkspaceMigrationRowLevelPermissionPredicateGroupActionsBuilderService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/row-level-permission-predicate-group/workspace-migration-row-level-permission-predicate-group-actions-builder.service';
 import { WorkspaceMigrationRowLevelPermissionPredicateActionsBuilderService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/row-level-permission-predicate/workspace-migration-row-level-permission-predicate-actions-builder.service';
-import { WorkspaceMigrationServerlessFunctionActionsBuilderService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/serverless-function/workspace-migration-serverless-function-actions-builder.service';
+import { WorkspaceMigrationLogicFunctionActionsBuilderService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/logic-function/workspace-migration-logic-function-actions-builder.service';
 import { WorkspaceMigrationSkillActionsBuilderService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/skill/workspace-migration-skill-actions-builder.service';
 import { WorkspaceMigrationViewFieldActionsBuilderService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/view-field/workspace-migration-view-field-actions-builder.service';
 import { WorkspaceMigrationViewFilterGroupActionsBuilderService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/view-filter-group/workspace-migration-view-filter-group-actions-builder.service';
@@ -47,7 +47,7 @@ export class WorkspaceMigrationBuildOrchestratorService {
     private readonly workspaceMigrationViewFilterActionsBuilderService: WorkspaceMigrationViewFilterActionsBuilderService,
     private readonly workspaceMigrationViewFilterGroupActionsBuilderService: WorkspaceMigrationViewFilterGroupActionsBuilderService,
     private readonly workspaceMigrationViewGroupActionsBuilderService: WorkspaceMigrationViewGroupActionsBuilderService,
-    private readonly workspaceMigrationServerlessFunctionActionsBuilderService: WorkspaceMigrationServerlessFunctionActionsBuilderService,
+    private readonly workspaceMigrationLogicFunctionActionsBuilderService: WorkspaceMigrationLogicFunctionActionsBuilderService,
     private readonly workspaceMigrationRoleTargetActionsBuilderService: WorkspaceMigrationRoleTargetActionsBuilderService,
     private readonly workspaceMigrationFieldActionsBuilderService: WorkspaceMigrationFieldActionsBuilderService,
     private readonly workspaceMigrationRoleActionsBuilderService: WorkspaceMigrationRoleActionsBuilderService,
@@ -144,7 +144,7 @@ export class WorkspaceMigrationBuildOrchestratorService {
       flatViewFieldMaps,
       flatViewMaps,
       flatIndexMaps,
-      flatServerlessFunctionMaps,
+      flatLogicFunctionMaps,
       flatFieldMetadataMaps,
       flatViewFilterMaps,
       flatViewFilterGroupMaps,
@@ -546,18 +546,16 @@ export class WorkspaceMigrationBuildOrchestratorService {
       }
     }
 
-    if (isDefined(flatServerlessFunctionMaps)) {
-      const {
-        from: fromFlatServerlessFunctionMaps,
-        to: toFlatServerlessFunctionMaps,
-      } = flatServerlessFunctionMaps;
+    if (isDefined(flatLogicFunctionMaps)) {
+      const { from: fromFlatLogicFunctionMaps, to: toFlatLogicFunctionMaps } =
+        flatLogicFunctionMaps;
 
-      const serverlessFunctionResult =
-        await this.workspaceMigrationServerlessFunctionActionsBuilderService.validateAndBuild(
+      const logicFunctionResult =
+        await this.workspaceMigrationLogicFunctionActionsBuilderService.validateAndBuild(
           {
             additionalCacheDataMaps,
-            from: fromFlatServerlessFunctionMaps,
-            to: toFlatServerlessFunctionMaps,
+            from: fromFlatLogicFunctionMaps,
+            to: toFlatLogicFunctionMaps,
             buildOptions,
             dependencyOptimisticFlatEntityMaps: undefined,
             workspaceId,
@@ -568,17 +566,16 @@ export class WorkspaceMigrationBuildOrchestratorService {
         {
           allFlatEntityMaps: optimisticAllFlatEntityMaps,
           flatEntityMapsAndRelatedFlatEntityMaps:
-            serverlessFunctionResult.optimisticFlatEntityMapsAndRelatedFlatEntityMaps,
+            logicFunctionResult.optimisticFlatEntityMapsAndRelatedFlatEntityMaps,
         },
       );
 
-      if (serverlessFunctionResult.status === 'fail') {
-        orchestratorFailureReport.serverlessFunction.push(
-          ...serverlessFunctionResult.errors,
+      if (logicFunctionResult.status === 'fail') {
+        orchestratorFailureReport.logicFunction.push(
+          ...logicFunctionResult.errors,
         );
       } else {
-        orchestratorActionsReport.serverlessFunction =
-          serverlessFunctionResult.actions;
+        orchestratorActionsReport.logicFunction = logicFunctionResult.actions;
       }
     }
 
@@ -1015,28 +1012,10 @@ export class WorkspaceMigrationBuildOrchestratorService {
           ...aggregatedOrchestratorActionsReport.viewGroup.update,
           ///
 
-          // Serverless functions
-          ...aggregatedOrchestratorActionsReport.serverlessFunction.delete,
-          ...aggregatedOrchestratorActionsReport.serverlessFunction.create,
-          ...aggregatedOrchestratorActionsReport.serverlessFunction.update,
-          ///
-
-          // Database event triggers
-          ...aggregatedOrchestratorActionsReport.databaseEventTrigger.delete,
-          ...aggregatedOrchestratorActionsReport.databaseEventTrigger.create,
-          ...aggregatedOrchestratorActionsReport.databaseEventTrigger.update,
-          ///
-
-          // Cron triggers
-          ...aggregatedOrchestratorActionsReport.cronTrigger.delete,
-          ...aggregatedOrchestratorActionsReport.cronTrigger.create,
-          ...aggregatedOrchestratorActionsReport.cronTrigger.update,
-          ///
-
-          // Route triggers
-          ...aggregatedOrchestratorActionsReport.routeTrigger.delete,
-          ...aggregatedOrchestratorActionsReport.routeTrigger.create,
-          ...aggregatedOrchestratorActionsReport.routeTrigger.update,
+          // Logic functions
+          ...aggregatedOrchestratorActionsReport.logicFunction.delete,
+          ...aggregatedOrchestratorActionsReport.logicFunction.create,
+          ...aggregatedOrchestratorActionsReport.logicFunction.update,
           ///
 
           // Roles

packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/logic-function/types/workspace-migration-logic-function-action.type.ts

@@ -4,13 +4,13 @@ import { type BaseCreateWorkspaceMigrationAction } from 'src/engine/workspace-ma
 import { type BaseDeleteWorkspaceMigrationAction } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/types/base-delete-workspace-migration-action.type';
 import { type BaseUpdateWorkspaceMigrationAction } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/types/base-update-workspace-migration-action.type';
 
-export type CreateServerlessFunctionAction =
-  BaseCreateWorkspaceMigrationAction<'serverlessFunction'>;
+export type CreateLogicFunctionAction =
+  BaseCreateWorkspaceMigrationAction<'logicFunction'>;
 
-export type UpdateServerlessFunctionAction =
-  BaseUpdateWorkspaceMigrationAction<'serverlessFunction'> & {
+export type UpdateLogicFunctionAction =
+  BaseUpdateWorkspaceMigrationAction<'logicFunction'> & {
     code?: Sources;
   };
 
-export type DeleteServerlessFunctionAction =
-  BaseDeleteWorkspaceMigrationAction<'serverlessFunction'>;
+export type DeleteLogicFunctionAction =
+  BaseDeleteWorkspaceMigrationAction<'logicFunction'>;

packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/logic-function/workspace-migration-logic-function-actions-builder.service.ts

@@ -3,7 +3,7 @@ import { Injectable } from '@nestjs/common';
 import { ALL_METADATA_NAME } from 'twenty-shared/metadata';
 
 import { findFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps.util';
-import { UpdateServerlessFunctionAction } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/serverless-function/types/workspace-migration-serverless-function-action.type';
+import { UpdateLogicFunctionAction } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/logic-function/types/workspace-migration-logic-function-action.type';
 import {
   ValidateAndBuildArgs,
   ValidateAndBuildReturnType,
@@ -12,21 +12,21 @@ import {
 import { FlatEntityUpdateValidationArgs } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/types/flat-entity-update-validation-args.type';
 import { FlatEntityValidationArgs } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/types/flat-entity-validation-args.type';
 import { FlatEntityValidationReturnType } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/types/flat-entity-validation-result.type';
-import { FlatServerlessFunctionValidatorService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/validators/services/flat-serverless-function-validator.service';
+import { FlatLogicFunctionValidatorService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/validators/services/flat-logic-function-validator.service';
 
 @Injectable()
-export class WorkspaceMigrationServerlessFunctionActionsBuilderService extends WorkspaceEntityMigrationBuilderService<
-  typeof ALL_METADATA_NAME.serverlessFunction
+export class WorkspaceMigrationLogicFunctionActionsBuilderService extends WorkspaceEntityMigrationBuilderService<
+  typeof ALL_METADATA_NAME.logicFunction
 > {
   constructor(
-    private readonly flatServerlessFunctionValidatorService: FlatServerlessFunctionValidatorService,
+    private readonly flatLogicFunctionValidatorService: FlatLogicFunctionValidatorService,
   ) {
-    super(ALL_METADATA_NAME.serverlessFunction);
+    super(ALL_METADATA_NAME.logicFunction);
   }
 
   public async validateAndBuild(
-    args: ValidateAndBuildArgs<typeof ALL_METADATA_NAME.serverlessFunction>,
-  ): ValidateAndBuildReturnType<typeof ALL_METADATA_NAME.serverlessFunction> {
+    args: ValidateAndBuildArgs<typeof ALL_METADATA_NAME.logicFunction>,
+  ): ValidateAndBuildReturnType<typeof ALL_METADATA_NAME.logicFunction> {
     const { to: toFlatEntityMaps } = args;
     const baseResult = await super.validateAndBuild(args);
 
@@ -39,14 +39,14 @@ export class WorkspaceMigrationServerlessFunctionActionsBuilderService extends W
         return action;
       }
 
-      const toServerlessFunction = findFlatEntityByIdInFlatEntityMaps({
+      const toLogicFunction = findFlatEntityByIdInFlatEntityMaps({
         flatEntityId: action.entityId,
         flatEntityMaps: toFlatEntityMaps,
       });
 
       return {
         ...action,
-        code: toServerlessFunction?.code,
+        code: toLogicFunction?.code,
       };
     });
 
@@ -60,13 +60,13 @@ export class WorkspaceMigrationServerlessFunctionActionsBuilderService extends W
   }
 
   protected validateFlatEntityCreation(
-    args: FlatEntityValidationArgs<typeof ALL_METADATA_NAME.serverlessFunction>,
+    args: FlatEntityValidationArgs<typeof ALL_METADATA_NAME.logicFunction>,
   ): FlatEntityValidationReturnType<
-    typeof ALL_METADATA_NAME.serverlessFunction,
+    typeof ALL_METADATA_NAME.logicFunction,
     'create'
   > {
     const validationResult =
-      this.flatServerlessFunctionValidatorService.validateFlatServerlessFunctionCreation(
+      this.flatLogicFunctionValidatorService.validateFlatLogicFunctionCreation(
         args,
       );
 
@@ -77,26 +77,26 @@ export class WorkspaceMigrationServerlessFunctionActionsBuilderService extends W
       };
     }
 
-    const { flatEntityToValidate: flatServerlessFunctionToValidate } = args;
+    const { flatEntityToValidate: flatLogicFunctionToValidate } = args;
 
     return {
       status: 'success',
       action: {
         type: 'create',
-        metadataName: 'serverlessFunction',
-        flatEntity: flatServerlessFunctionToValidate,
+        metadataName: 'logicFunction',
+        flatEntity: flatLogicFunctionToValidate,
       },
     };
   }
 
   protected validateFlatEntityDeletion(
-    args: FlatEntityValidationArgs<typeof ALL_METADATA_NAME.serverlessFunction>,
+    args: FlatEntityValidationArgs<typeof ALL_METADATA_NAME.logicFunction>,
   ): FlatEntityValidationReturnType<
-    typeof ALL_METADATA_NAME.serverlessFunction,
+    typeof ALL_METADATA_NAME.logicFunction,
     'delete'
   > {
     const validationResult =
-      this.flatServerlessFunctionValidatorService.validateFlatServerlessFunctionDeletion(
+      this.flatLogicFunctionValidatorService.validateFlatLogicFunctionDeletion(
         args,
       );
 
@@ -107,29 +107,28 @@ export class WorkspaceMigrationServerlessFunctionActionsBuilderService extends W
       };
     }
 
-    const { flatEntityToValidate: flatServerlessFunctionToValidate } = args;
+    const { flatEntityToValidate: flatLogicFunctionToValidate } = args;
 
     return {
       status: 'success',
       action: {
         type: 'delete',
-        metadataName: 'serverlessFunction',
-        universalIdentifier:
-          flatServerlessFunctionToValidate.universalIdentifier,
+        metadataName: 'logicFunction',
+        universalIdentifier: flatLogicFunctionToValidate.universalIdentifier,
       },
     };
   }
 
   protected validateFlatEntityUpdate(
     args: FlatEntityUpdateValidationArgs<
-      typeof ALL_METADATA_NAME.serverlessFunction
+      typeof ALL_METADATA_NAME.logicFunction
     >,
   ): FlatEntityValidationReturnType<
-    typeof ALL_METADATA_NAME.serverlessFunction,
+    typeof ALL_METADATA_NAME.logicFunction,
     'update'
   > {
     const validationResult =
-      this.flatServerlessFunctionValidatorService.validateFlatServerlessFunctionUpdate(
+      this.flatLogicFunctionValidatorService.validateFlatLogicFunctionUpdate(
         args,
       );
 
@@ -142,16 +141,16 @@ export class WorkspaceMigrationServerlessFunctionActionsBuilderService extends W
 
     const { flatEntityId, flatEntityUpdates } = args;
 
-    const updateServerlessFunctionAction: UpdateServerlessFunctionAction = {
+    const updateLogicFunctionAction: UpdateLogicFunctionAction = {
       type: 'update',
-      metadataName: 'serverlessFunction',
+      metadataName: 'logicFunction',
       entityId: flatEntityId,
       updates: flatEntityUpdates,
     };
 
     return {
       status: 'success',
-      action: updateServerlessFunctionAction,
+      action: updateLogicFunctionAction,
     };
   }
 }

packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-builder/validators/services/flat-logic-function-validator.service.ts

@@ -0,0 +1,110 @@
+import { Injectable } from '@nestjs/common';
+
+import { msg, t } from '@lingui/core/macro';
+import { ALL_METADATA_NAME } from 'twenty-shared/metadata';
+import { isDefined } from 'twenty-shared/utils';
+
+import { LogicFunctionExceptionCode } from 'src/engine/metadata-modules/logic-function/logic-function.exception';
+import { FailedFlatEntityValidation } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/types/failed-flat-entity-validation.type';
+import { getEmptyFlatEntityValidationError } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/utils/get-flat-entity-validation-error.util';
+import { FlatEntityUpdateValidationArgs } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/types/flat-entity-update-validation-args.type';
+import { FlatEntityValidationArgs } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/types/flat-entity-validation-args.type';
+
+@Injectable()
+export class FlatLogicFunctionValidatorService {
+  constructor() {}
+
+  public validateFlatLogicFunctionUpdate({
+    flatEntityId,
+    optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
+      flatLogicFunctionMaps: optimisticFlatLogicFunctionMaps,
+    },
+  }: FlatEntityUpdateValidationArgs<
+    typeof ALL_METADATA_NAME.logicFunction
+  >): FailedFlatEntityValidation<'logicFunction', 'update'> {
+    const existingFlatLogicFunction =
+      optimisticFlatLogicFunctionMaps.byId[flatEntityId];
+
+    const validationResult = getEmptyFlatEntityValidationError({
+      flatEntityMinimalInformation: {
+        id: flatEntityId,
+        universalIdentifier: existingFlatLogicFunction?.universalIdentifier,
+      },
+      metadataName: 'logicFunction',
+      type: 'update',
+    });
+
+    if (!isDefined(existingFlatLogicFunction)) {
+      validationResult.errors.push({
+        code: LogicFunctionExceptionCode.LOGIC_FUNCTION_NOT_FOUND,
+        message: t`Logic function not found`,
+        userFriendlyMessage: msg`Logic function not found`,
+      });
+    }
+
+    return validationResult;
+  }
+
+  public validateFlatLogicFunctionDeletion({
+    flatEntityToValidate: { id: logicFunctionIdToDelete, universalIdentifier },
+    optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
+      flatLogicFunctionMaps: optimisticFlatLogicFunctionMaps,
+    },
+  }: FlatEntityValidationArgs<
+    typeof ALL_METADATA_NAME.logicFunction
+  >): FailedFlatEntityValidation<'logicFunction', 'delete'> {
+    const validationResult = getEmptyFlatEntityValidationError({
+      flatEntityMinimalInformation: {
+        id: logicFunctionIdToDelete,
+        universalIdentifier,
+      },
+      metadataName: 'logicFunction',
+      type: 'delete',
+    });
+
+    const existingFlatLogicFunction =
+      optimisticFlatLogicFunctionMaps.byId[logicFunctionIdToDelete];
+
+    if (!isDefined(existingFlatLogicFunction)) {
+      validationResult.errors.push({
+        code: LogicFunctionExceptionCode.LOGIC_FUNCTION_NOT_FOUND,
+        message: t`Logic function not found`,
+        userFriendlyMessage: msg`Logic function not found`,
+      });
+    }
+
+    return validationResult;
+  }
+
+  public validateFlatLogicFunctionCreation({
+    flatEntityToValidate: flatLogicFunctionToValidate,
+    optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
+      flatLogicFunctionMaps: optimisticFlatLogicFunctionMaps,
+    },
+  }: FlatEntityValidationArgs<
+    typeof ALL_METADATA_NAME.logicFunction
+  >): FailedFlatEntityValidation<'logicFunction', 'create'> {
+    const validationResult = getEmptyFlatEntityValidationError({
+      flatEntityMinimalInformation: {
+        id: flatLogicFunctionToValidate.id,
+        universalIdentifier: flatLogicFunctionToValidate.universalIdentifier,
+      },
+      metadataName: 'logicFunction',
+      type: 'create',
+    });
+
+    if (
+      isDefined(
+        optimisticFlatLogicFunctionMaps.byId[flatLogicFunctionToValidate.id],
+      )
+    ) {
+      validationResult.errors.push({
+        code: LogicFunctionExceptionCode.LOGIC_FUNCTION_ALREADY_EXIST,
+        message: t`Logic function with same id already exists`,
+        userFriendlyMessage: msg`Logic function already exists`,
+      });
+    }
+
+    return validationResult;
+  }
+}

packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-builder/validators/services/flat-serverless-function-validator.service.ts

@@ -1,117 +0,0 @@
-import { Injectable } from '@nestjs/common';
-
-import { msg, t } from '@lingui/core/macro';
-import { ALL_METADATA_NAME } from 'twenty-shared/metadata';
-import { isDefined } from 'twenty-shared/utils';
-
-import { ServerlessFunctionExceptionCode } from 'src/engine/metadata-modules/serverless-function/serverless-function.exception';
-import { FailedFlatEntityValidation } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/types/failed-flat-entity-validation.type';
-import { getEmptyFlatEntityValidationError } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/utils/get-flat-entity-validation-error.util';
-import { FlatEntityUpdateValidationArgs } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/types/flat-entity-update-validation-args.type';
-import { FlatEntityValidationArgs } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/types/flat-entity-validation-args.type';
-
-@Injectable()
-export class FlatServerlessFunctionValidatorService {
-  constructor() {}
-
-  public validateFlatServerlessFunctionUpdate({
-    flatEntityId,
-    optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
-      flatServerlessFunctionMaps: optimisticFlatServerlessFunctionMaps,
-    },
-  }: FlatEntityUpdateValidationArgs<
-    typeof ALL_METADATA_NAME.serverlessFunction
-  >): FailedFlatEntityValidation<'serverlessFunction', 'update'> {
-    const existingFlatServerlessFunction =
-      optimisticFlatServerlessFunctionMaps.byId[flatEntityId];
-
-    const validationResult = getEmptyFlatEntityValidationError({
-      flatEntityMinimalInformation: {
-        id: flatEntityId,
-        universalIdentifier:
-          existingFlatServerlessFunction?.universalIdentifier,
-      },
-      metadataName: 'serverlessFunction',
-      type: 'update',
-    });
-
-    if (!isDefined(existingFlatServerlessFunction)) {
-      validationResult.errors.push({
-        code: ServerlessFunctionExceptionCode.SERVERLESS_FUNCTION_NOT_FOUND,
-        message: t`Serverless function not found`,
-        userFriendlyMessage: msg`Serverless function not found`,
-      });
-    }
-
-    return validationResult;
-  }
-
-  public validateFlatServerlessFunctionDeletion({
-    flatEntityToValidate: {
-      id: serverlessFunctionIdToDelete,
-      universalIdentifier,
-    },
-    optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
-      flatServerlessFunctionMaps: optimisticFlatServerlessFunctionMaps,
-    },
-  }: FlatEntityValidationArgs<
-    typeof ALL_METADATA_NAME.serverlessFunction
-  >): FailedFlatEntityValidation<'serverlessFunction', 'delete'> {
-    const validationResult = getEmptyFlatEntityValidationError({
-      flatEntityMinimalInformation: {
-        id: serverlessFunctionIdToDelete,
-        universalIdentifier,
-      },
-      metadataName: 'serverlessFunction',
-      type: 'delete',
-    });
-
-    const existingFlatServerlessFunction =
-      optimisticFlatServerlessFunctionMaps.byId[serverlessFunctionIdToDelete];
-
-    if (!isDefined(existingFlatServerlessFunction)) {
-      validationResult.errors.push({
-        code: ServerlessFunctionExceptionCode.SERVERLESS_FUNCTION_NOT_FOUND,
-        message: t`Serverless function not found`,
-        userFriendlyMessage: msg`Serverless function not found`,
-      });
-    }
-
-    return validationResult;
-  }
-
-  public validateFlatServerlessFunctionCreation({
-    flatEntityToValidate: flatServerlessFunctionToValidate,
-    optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
-      flatServerlessFunctionMaps: optimisticFlatServerlessFunctionMaps,
-    },
-  }: FlatEntityValidationArgs<
-    typeof ALL_METADATA_NAME.serverlessFunction
-  >): FailedFlatEntityValidation<'serverlessFunction', 'create'> {
-    const validationResult = getEmptyFlatEntityValidationError({
-      flatEntityMinimalInformation: {
-        id: flatServerlessFunctionToValidate.id,
-        universalIdentifier:
-          flatServerlessFunctionToValidate.universalIdentifier,
-      },
-      metadataName: 'serverlessFunction',
-      type: 'create',
-    });
-
-    if (
-      isDefined(
-        optimisticFlatServerlessFunctionMaps.byId[
-          flatServerlessFunctionToValidate.id
-        ],
-      )
-    ) {
-      validationResult.errors.push({
-        code: ServerlessFunctionExceptionCode.SERVERLESS_FUNCTION_ALREADY_EXIST,
-        message: t`Serverless function with same id already exists`,
-        userFriendlyMessage: msg`Serverless function already exists`,
-      });
-    }
-
-    return validationResult;
-  }
-}

packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-builder/validators/workspace-migration-builder-validators.module.ts

@@ -17,7 +17,7 @@ import { FlatRoleTargetValidatorService } from 'src/engine/workspace-manager/wor
 import { FlatRoleValidatorService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/validators/services/flat-role-validator.service';
 import { FlatRowLevelPermissionPredicateGroupValidatorService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/validators/services/flat-row-level-permission-predicate-group-validator.service';
 import { FlatRowLevelPermissionPredicateValidatorService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/validators/services/flat-row-level-permission-predicate-validator.service';
-import { FlatServerlessFunctionValidatorService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/validators/services/flat-serverless-function-validator.service';
+import { FlatLogicFunctionValidatorService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/validators/services/flat-logic-function-validator.service';
 import { FlatSkillValidatorService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/validators/services/flat-skill-validator.service';
 import { FlatViewFieldValidatorService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/validators/services/flat-view-field-validator.service';
 import { FlatViewFilterGroupValidatorService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/validators/services/flat-view-filter-group-validator.service';
@@ -37,7 +37,7 @@ import { FlatWebhookValidatorService } from 'src/engine/workspace-manager/worksp
     FlatIndexValidatorService,
     FlatFieldMetadataValidatorService,
     FlatObjectMetadataValidatorService,
-    FlatServerlessFunctionValidatorService,
+    FlatLogicFunctionValidatorService,
     FlatFieldMetadataTypeValidatorService,
     FlatPageLayoutWidgetTypeValidatorService,
     FlatRoleValidatorService,
@@ -63,7 +63,7 @@ import { FlatWebhookValidatorService } from 'src/engine/workspace-manager/worksp
     FlatIndexValidatorService,
     FlatFieldMetadataValidatorService,
     FlatObjectMetadataValidatorService,
-    FlatServerlessFunctionValidatorService,
+    FlatLogicFunctionValidatorService,
     FlatFieldMetadataTypeValidatorService,
     FlatRoleValidatorService,
     FlatRoleTargetValidatorService,

packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-builder/workspace-migration-builder.module.ts

@@ -15,7 +15,7 @@ import { WorkspaceMigrationRoleTargetActionsBuilderService } from 'src/engine/wo
 import { WorkspaceMigrationRoleActionsBuilderService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/role/workspace-migration-role-actions-builder.service';
 import { WorkspaceMigrationRowLevelPermissionPredicateGroupActionsBuilderService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/row-level-permission-predicate-group/workspace-migration-row-level-permission-predicate-group-actions-builder.service';
 import { WorkspaceMigrationRowLevelPermissionPredicateActionsBuilderService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/row-level-permission-predicate/workspace-migration-row-level-permission-predicate-actions-builder.service';
-import { WorkspaceMigrationServerlessFunctionActionsBuilderService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/serverless-function/workspace-migration-serverless-function-actions-builder.service';
+import { WorkspaceMigrationLogicFunctionActionsBuilderService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/logic-function/workspace-migration-logic-function-actions-builder.service';
 import { WorkspaceMigrationSkillActionsBuilderService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/skill/workspace-migration-skill-actions-builder.service';
 import { WorkspaceMigrationFrontComponentActionsBuilderService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/front-component/workspace-migration-front-component-actions-builder.service';
 import { WorkspaceMigrationViewFieldActionsBuilderService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/view-field/workspace-migration-view-field-actions-builder.service';
@@ -37,7 +37,7 @@ import { WorkspaceMigrationBuilderValidatorsModule } from 'src/engine/workspace-
     WorkspaceMigrationViewFilterGroupActionsBuilderService,
     WorkspaceMigrationViewGroupActionsBuilderService,
     WorkspaceMigrationIndexActionsBuilderService,
-    WorkspaceMigrationServerlessFunctionActionsBuilderService,
+    WorkspaceMigrationLogicFunctionActionsBuilderService,
     WorkspaceMigrationFieldActionsBuilderService,
     WorkspaceMigrationRoleActionsBuilderService,
     WorkspaceMigrationRoleTargetActionsBuilderService,
@@ -62,7 +62,7 @@ import { WorkspaceMigrationBuilderValidatorsModule } from 'src/engine/workspace-
     WorkspaceMigrationViewFilterGroupActionsBuilderService,
     WorkspaceMigrationViewGroupActionsBuilderService,
     WorkspaceMigrationFieldActionsBuilderService,
-    WorkspaceMigrationServerlessFunctionActionsBuilderService,
+    WorkspaceMigrationLogicFunctionActionsBuilderService,
     WorkspaceMigrationRoleActionsBuilderService,
     WorkspaceMigrationRoleTargetActionsBuilderService,
     WorkspaceMigrationAgentActionsBuilderService,

packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/logic-function/services/create-logic-function-action-handler.service.ts

@@ -0,0 +1,87 @@
+import { Injectable } from '@nestjs/common';
+
+import { join } from 'path';
+
+import { isDefined } from 'twenty-shared/utils';
+
+import { WorkspaceMigrationRunnerActionHandler } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/interfaces/workspace-migration-runner-action-handler-service.interface';
+
+import { FileStorageService } from 'src/engine/core-modules/file-storage/file-storage.service';
+import { getSeedProjectFiles } from 'src/engine/core-modules/logic-function-executor/drivers/utils/get-seed-project-files';
+import { getLogicFunctionFolderOrThrow } from 'src/engine/core-modules/logic-function-executor/utils/get-logic-function-folder-or-throw.utils';
+import { LogicFunctionEntity } from 'src/engine/metadata-modules/logic-function/logic-function.entity';
+import { CreateLogicFunctionAction } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/logic-function/types/workspace-migration-logic-function-action.type';
+import { WorkspaceMigrationActionRunnerArgs } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/types/workspace-migration-action-runner-args.type';
+import { FlatLogicFunction } from 'src/engine/metadata-modules/logic-function/types/flat-logic-function.type';
+import { FunctionBuildService } from 'src/engine/metadata-modules/function-build/function-build.service';
+
+@Injectable()
+export class CreateLogicFunctionActionHandlerService extends WorkspaceMigrationRunnerActionHandler(
+  'create',
+  'logicFunction',
+) {
+  constructor(
+    private readonly fileStorageService: FileStorageService,
+    private readonly functionBuildService: FunctionBuildService,
+  ) {
+    super();
+  }
+
+  async executeForMetadata(
+    context: WorkspaceMigrationActionRunnerArgs<CreateLogicFunctionAction>,
+  ): Promise<void> {
+    const { action, queryRunner, workspaceId } = context;
+    const { flatEntity: logicFunction } = action;
+
+    await this.buildAndSaveLogicFunction(logicFunction);
+
+    const logicFunctionRepository =
+      queryRunner.manager.getRepository<LogicFunctionEntity>(
+        LogicFunctionEntity,
+      );
+
+    await logicFunctionRepository.insert({
+      ...logicFunction,
+      workspaceId,
+    });
+  }
+
+  private async buildAndSaveLogicFunction(logicFunction: FlatLogicFunction) {
+    const draftFileFolder = getLogicFunctionFolderOrThrow({
+      flatLogicFunction: logicFunction,
+      version: 'draft',
+    });
+
+    if (isDefined(logicFunction?.code)) {
+      await this.fileStorageService.writeFolder(
+        logicFunction.code,
+        draftFileFolder,
+      );
+    } else {
+      for (const file of await getSeedProjectFiles) {
+        await this.fileStorageService.write({
+          file: file.content,
+          name: file.name,
+          mimeType: 'application/typescript',
+          folder: join(draftFileFolder, file.path),
+        });
+      }
+    }
+    await this.functionBuildService.buildAndUpload({
+      flatLogicFunction: logicFunction,
+      version: 'draft',
+    });
+  }
+
+  async rollbackForMetadata(
+    context: WorkspaceMigrationActionRunnerArgs<CreateLogicFunctionAction>,
+  ): Promise<void> {
+    const { action } = context;
+
+    await this.fileStorageService.delete({
+      folderPath: getLogicFunctionFolderOrThrow({
+        flatLogicFunction: action.flatEntity,
+      }),
+    });
+  }
+}

packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/logic-function/services/delete-logic-function-action-handler.service.ts

@@ -0,0 +1,98 @@
+import { Injectable } from '@nestjs/common';
+
+import { FileFolder } from 'twenty-shared/types';
+
+import { WorkspaceMigrationRunnerActionHandler } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/interfaces/workspace-migration-runner-action-handler-service.interface';
+
+import { FileStorageService } from 'src/engine/core-modules/file-storage/file-storage.service';
+import { getLogicFunctionFolderOrThrow } from 'src/engine/core-modules/logic-function-executor/utils/get-logic-function-folder-or-throw.utils';
+import { findFlatEntityByUniversalIdentifierOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-universal-identifier-or-throw.util';
+import { LogicFunctionEntity } from 'src/engine/metadata-modules/logic-function/logic-function.entity';
+import { DeleteLogicFunctionAction } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/logic-function/types/workspace-migration-logic-function-action.type';
+import { WorkspaceMigrationActionRunnerArgs } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/types/workspace-migration-action-runner-args.type';
+
+@Injectable()
+export class DeleteLogicFunctionActionHandlerService extends WorkspaceMigrationRunnerActionHandler(
+  'delete',
+  'logicFunction',
+) {
+  constructor(private readonly fileStorageService: FileStorageService) {
+    super();
+  }
+
+  async executeForMetadata(
+    context: WorkspaceMigrationActionRunnerArgs<DeleteLogicFunctionAction>,
+  ): Promise<void> {
+    const { action, queryRunner, workspaceId, allFlatEntityMaps } = context;
+    const { universalIdentifier } = action;
+
+    const flatLogicFunction = findFlatEntityByUniversalIdentifierOrThrow({
+      flatEntityMaps: allFlatEntityMaps.flatLogicFunctionMaps,
+      universalIdentifier,
+    });
+
+    const logicFunctionRepository =
+      queryRunner.manager.getRepository<LogicFunctionEntity>(
+        LogicFunctionEntity,
+      );
+
+    await logicFunctionRepository.delete({
+      id: flatLogicFunction.id,
+      workspaceId,
+    });
+
+    // TODO: Should implement a cron task or a job to delete the files after a certain period of time
+    await this.fileStorageService.move({
+      from: {
+        folderPath: getLogicFunctionFolderOrThrow({
+          flatLogicFunction,
+          fileFolder: FileFolder.LogicFunction,
+        }),
+      },
+      to: {
+        folderPath: getLogicFunctionFolderOrThrow({
+          flatLogicFunction,
+          fileFolder: FileFolder.LogicFunctionToDelete,
+        }),
+      },
+    });
+
+    // We can delete built code as it can be computed from source code if rollback occurs
+    await this.fileStorageService.delete({
+      folderPath: getLogicFunctionFolderOrThrow({
+        flatLogicFunction,
+        fileFolder: FileFolder.BuiltFunction,
+      }),
+    });
+  }
+
+  async rollbackForMetadata(
+    context: Omit<
+      WorkspaceMigrationActionRunnerArgs<DeleteLogicFunctionAction>,
+      'queryRunner'
+    >,
+  ): Promise<void> {
+    const { action, allFlatEntityMaps } = context;
+    const { universalIdentifier } = action;
+
+    const flatLogicFunction = findFlatEntityByUniversalIdentifierOrThrow({
+      flatEntityMaps: allFlatEntityMaps.flatLogicFunctionMaps,
+      universalIdentifier,
+    });
+
+    await this.fileStorageService.move({
+      from: {
+        folderPath: getLogicFunctionFolderOrThrow({
+          flatLogicFunction,
+          fileFolder: FileFolder.LogicFunctionToDelete,
+        }),
+      },
+      to: {
+        folderPath: getLogicFunctionFolderOrThrow({
+          flatLogicFunction,
+          fileFolder: FileFolder.LogicFunction,
+        }),
+      },
+    });
+  }
+}

packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/logic-function/services/update-logic-function-action-handler.service.ts

@@ -6,89 +6,89 @@ import { isDefined } from 'twenty-shared/utils';
 import { WorkspaceMigrationRunnerActionHandler } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/interfaces/workspace-migration-runner-action-handler-service.interface';
 
 import { FileStorageService } from 'src/engine/core-modules/file-storage/file-storage.service';
-import { ServerlessService } from 'src/engine/core-modules/serverless/serverless.service';
-import { getServerlessFolderOrThrow } from 'src/engine/core-modules/serverless/utils/get-serverless-folder-or-throw.utils';
+import { LogicFunctionExecutorService } from 'src/engine/core-modules/logic-function-executor/logic-function-executor.service';
+import { getLogicFunctionFolderOrThrow } from 'src/engine/core-modules/logic-function-executor/utils/get-logic-function-folder-or-throw.utils';
 import { findFlatEntityByIdInFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps-or-throw.util';
-import { ServerlessFunctionEntity } from 'src/engine/metadata-modules/serverless-function/serverless-function.entity';
-import { FlatServerlessFunction } from 'src/engine/metadata-modules/serverless-function/types/flat-serverless-function.type';
-import { UpdateServerlessFunctionAction } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/serverless-function/types/workspace-migration-serverless-function-action.type';
+import { LogicFunctionEntity } from 'src/engine/metadata-modules/logic-function/logic-function.entity';
+import { FlatLogicFunction } from 'src/engine/metadata-modules/logic-function/types/flat-logic-function.type';
+import { UpdateLogicFunctionAction } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/logic-function/types/workspace-migration-logic-function-action.type';
 import { WorkspaceMigrationActionRunnerArgs } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/types/workspace-migration-action-runner-args.type';
 import { fromFlatEntityPropertiesUpdatesToPartialFlatEntity } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/utils/from-flat-entity-properties-updates-to-partial-flat-entity';
 import { FunctionBuildService } from 'src/engine/metadata-modules/function-build/function-build.service';
 
 @Injectable()
-export class UpdateServerlessFunctionActionHandlerService extends WorkspaceMigrationRunnerActionHandler(
+export class UpdateLogicFunctionActionHandlerService extends WorkspaceMigrationRunnerActionHandler(
   'update',
-  'serverlessFunction',
+  'logicFunction',
 ) {
   constructor(
     private readonly fileStorageService: FileStorageService,
-    private readonly serverlessService: ServerlessService,
+    private readonly logicFunctionExecutorService: LogicFunctionExecutorService,
     private readonly functionBuildService: FunctionBuildService,
   ) {
     super();
   }
 
   async executeForMetadata(
-    context: WorkspaceMigrationActionRunnerArgs<UpdateServerlessFunctionAction>,
+    context: WorkspaceMigrationActionRunnerArgs<UpdateLogicFunctionAction>,
   ): Promise<void> {
     const { action, queryRunner } = context;
     const { entityId, code } = action;
 
-    const serverlessFunctionRepository =
-      queryRunner.manager.getRepository<ServerlessFunctionEntity>(
-        ServerlessFunctionEntity,
+    const logicFunctionRepository =
+      queryRunner.manager.getRepository<LogicFunctionEntity>(
+        LogicFunctionEntity,
       );
 
-    await serverlessFunctionRepository.update(
+    await logicFunctionRepository.update(
       entityId,
       fromFlatEntityPropertiesUpdatesToPartialFlatEntity(action),
     );
 
-    const flatServerlessFunction = findFlatEntityByIdInFlatEntityMapsOrThrow({
+    const flatLogicFunction = findFlatEntityByIdInFlatEntityMapsOrThrow({
       flatEntityId: entityId,
-      flatEntityMaps: context.allFlatEntityMaps.flatServerlessFunctionMaps,
+      flatEntityMaps: context.allFlatEntityMaps.flatLogicFunctionMaps,
     });
 
     for (const update of action.updates) {
       if (update.property === 'checksum' && isDefined(code)) {
         await this.handleChecksumUpdate({
-          flatServerlessFunction,
+          flatLogicFunction,
           code,
         });
       }
       if (update.property === 'deletedAt' && isDefined(update.to)) {
         await this.handleDeletedAtUpdate({
-          flatServerlessFunction,
+          flatLogicFunction,
         });
       }
     }
   }
 
   async handleDeletedAtUpdate({
-    flatServerlessFunction,
+    flatLogicFunction,
   }: {
-    flatServerlessFunction: FlatServerlessFunction;
+    flatLogicFunction: FlatLogicFunction;
   }) {
-    this.serverlessService.delete(flatServerlessFunction);
+    this.logicFunctionExecutorService.delete(flatLogicFunction);
   }
 
   async handleChecksumUpdate({
-    flatServerlessFunction,
+    flatLogicFunction,
     code,
   }: {
-    flatServerlessFunction: FlatServerlessFunction;
+    flatLogicFunction: FlatLogicFunction;
     code: Sources;
   }) {
-    const fileFolder = getServerlessFolderOrThrow({
-      flatServerlessFunction,
+    const fileFolder = getLogicFunctionFolderOrThrow({
+      flatLogicFunction,
       version: 'draft',
     });
 
     await this.fileStorageService.writeFolder(code, fileFolder);
 
     await this.functionBuildService.buildAndUpload({
-      flatServerlessFunction,
+      flatLogicFunction,
       version: 'draft',
     });
   }

packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/serverless-function/services/create-serverless-function-action-handler.service.ts

@@ -1,89 +0,0 @@
-import { Injectable } from '@nestjs/common';
-
-import { join } from 'path';
-
-import { isDefined } from 'twenty-shared/utils';
-
-import { WorkspaceMigrationRunnerActionHandler } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/interfaces/workspace-migration-runner-action-handler-service.interface';
-
-import { FileStorageService } from 'src/engine/core-modules/file-storage/file-storage.service';
-import { getSeedProjectFiles } from 'src/engine/core-modules/serverless/drivers/utils/get-seed-project-files';
-import { getServerlessFolderOrThrow } from 'src/engine/core-modules/serverless/utils/get-serverless-folder-or-throw.utils';
-import { ServerlessFunctionEntity } from 'src/engine/metadata-modules/serverless-function/serverless-function.entity';
-import { CreateServerlessFunctionAction } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/serverless-function/types/workspace-migration-serverless-function-action.type';
-import { WorkspaceMigrationActionRunnerArgs } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/types/workspace-migration-action-runner-args.type';
-import { FlatServerlessFunction } from 'src/engine/metadata-modules/serverless-function/types/flat-serverless-function.type';
-import { FunctionBuildService } from 'src/engine/metadata-modules/function-build/function-build.service';
-
-@Injectable()
-export class CreateServerlessFunctionActionHandlerService extends WorkspaceMigrationRunnerActionHandler(
-  'create',
-  'serverlessFunction',
-) {
-  constructor(
-    private readonly fileStorageService: FileStorageService,
-    private readonly functionBuildService: FunctionBuildService,
-  ) {
-    super();
-  }
-
-  async executeForMetadata(
-    context: WorkspaceMigrationActionRunnerArgs<CreateServerlessFunctionAction>,
-  ): Promise<void> {
-    const { action, queryRunner, workspaceId } = context;
-    const { flatEntity: serverlessFunction } = action;
-
-    await this.buildAndSaveServerlessFunction(serverlessFunction);
-
-    const serverlessFunctionRepository =
-      queryRunner.manager.getRepository<ServerlessFunctionEntity>(
-        ServerlessFunctionEntity,
-      );
-
-    await serverlessFunctionRepository.insert({
-      ...serverlessFunction,
-      workspaceId,
-    });
-  }
-
-  private async buildAndSaveServerlessFunction(
-    serverlessFunction: FlatServerlessFunction,
-  ) {
-    const draftFileFolder = getServerlessFolderOrThrow({
-      flatServerlessFunction: serverlessFunction,
-      version: 'draft',
-    });
-
-    if (isDefined(serverlessFunction?.code)) {
-      await this.fileStorageService.writeFolder(
-        serverlessFunction.code,
-        draftFileFolder,
-      );
-    } else {
-      for (const file of await getSeedProjectFiles) {
-        await this.fileStorageService.write({
-          file: file.content,
-          name: file.name,
-          mimeType: 'application/typescript',
-          folder: join(draftFileFolder, file.path),
-        });
-      }
-    }
-    await this.functionBuildService.buildAndUpload({
-      flatServerlessFunction: serverlessFunction,
-      version: 'draft',
-    });
-  }
-
-  async rollbackForMetadata(
-    context: WorkspaceMigrationActionRunnerArgs<CreateServerlessFunctionAction>,
-  ): Promise<void> {
-    const { action } = context;
-
-    await this.fileStorageService.delete({
-      folderPath: getServerlessFolderOrThrow({
-        flatServerlessFunction: action.flatEntity,
-      }),
-    });
-  }
-}

packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/serverless-function/services/delete-serverless-function-action-handler.service.ts

@@ -1,98 +0,0 @@
-import { Injectable } from '@nestjs/common';
-
-import { FileFolder } from 'twenty-shared/types';
-
-import { WorkspaceMigrationRunnerActionHandler } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/interfaces/workspace-migration-runner-action-handler-service.interface';
-
-import { FileStorageService } from 'src/engine/core-modules/file-storage/file-storage.service';
-import { getServerlessFolderOrThrow } from 'src/engine/core-modules/serverless/utils/get-serverless-folder-or-throw.utils';
-import { findFlatEntityByUniversalIdentifierOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-universal-identifier-or-throw.util';
-import { ServerlessFunctionEntity } from 'src/engine/metadata-modules/serverless-function/serverless-function.entity';
-import { DeleteServerlessFunctionAction } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/builders/serverless-function/types/workspace-migration-serverless-function-action.type';
-import { WorkspaceMigrationActionRunnerArgs } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/types/workspace-migration-action-runner-args.type';
-
-@Injectable()
-export class DeleteServerlessFunctionActionHandlerService extends WorkspaceMigrationRunnerActionHandler(
-  'delete',
-  'serverlessFunction',
-) {
-  constructor(private readonly fileStorageService: FileStorageService) {
-    super();
-  }
-
-  async executeForMetadata(
-    context: WorkspaceMigrationActionRunnerArgs<DeleteServerlessFunctionAction>,
-  ): Promise<void> {
-    const { action, queryRunner, workspaceId, allFlatEntityMaps } = context;
-    const { universalIdentifier } = action;
-
-    const flatServerlessFunction = findFlatEntityByUniversalIdentifierOrThrow({
-      flatEntityMaps: allFlatEntityMaps.flatServerlessFunctionMaps,
-      universalIdentifier,
-    });
-
-    const serverlessFunctionRepository =
-      queryRunner.manager.getRepository<ServerlessFunctionEntity>(
-        ServerlessFunctionEntity,
-      );
-
-    await serverlessFunctionRepository.delete({
-      id: flatServerlessFunction.id,
-      workspaceId,
-    });
-
-    // TODO: Should implement a cron task or a job to delete the files after a certain period of time
-    await this.fileStorageService.move({
-      from: {
-        folderPath: getServerlessFolderOrThrow({
-          flatServerlessFunction,
-          fileFolder: FileFolder.ServerlessFunction,
-        }),
-      },
-      to: {
-        folderPath: getServerlessFolderOrThrow({
-          flatServerlessFunction,
-          fileFolder: FileFolder.ServerlessFunctionToDelete,
-        }),
-      },
-    });
-
-    // We can delete built code as it can be computed from source code if rollback occurs
-    await this.fileStorageService.delete({
-      folderPath: getServerlessFolderOrThrow({
-        flatServerlessFunction,
-        fileFolder: FileFolder.BuiltFunction,
-      }),
-    });
-  }
-
-  async rollbackForMetadata(
-    context: Omit<
-      WorkspaceMigrationActionRunnerArgs<DeleteServerlessFunctionAction>,
-      'queryRunner'
-    >,
-  ): Promise<void> {
-    const { action, allFlatEntityMaps } = context;
-    const { universalIdentifier } = action;
-
-    const flatServerlessFunction = findFlatEntityByUniversalIdentifierOrThrow({
-      flatEntityMaps: allFlatEntityMaps.flatServerlessFunctionMaps,
-      universalIdentifier,
-    });
-
-    await this.fileStorageService.move({
-      from: {
-        folderPath: getServerlessFolderOrThrow({
-          flatServerlessFunction,
-          fileFolder: FileFolder.ServerlessFunctionToDelete,
-        }),
-      },
-      to: {
-        folderPath: getServerlessFolderOrThrow({
-          flatServerlessFunction,
-          fileFolder: FileFolder.ServerlessFunction,
-        }),
-      },
-    });
-  }
-}

packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/workspace-schema-migration-runner-action-handlers.module.ts

@@ -40,9 +40,9 @@ import { UpdateRowLevelPermissionPredicateGroupActionHandlerService } from 'src/
 import { CreateRowLevelPermissionPredicateActionHandlerService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/row-level-permission-predicate/services/create-row-level-permission-predicate-action-handler.service';
 import { DeleteRowLevelPermissionPredicateActionHandlerService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/row-level-permission-predicate/services/delete-row-level-permission-predicate-action-handler.service';
 import { UpdateRowLevelPermissionPredicateActionHandlerService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/row-level-permission-predicate/services/update-row-level-permission-predicate-action-handler.service';
-import { CreateServerlessFunctionActionHandlerService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/serverless-function/services/create-serverless-function-action-handler.service';
-import { DeleteServerlessFunctionActionHandlerService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/serverless-function/services/delete-serverless-function-action-handler.service';
-import { UpdateServerlessFunctionActionHandlerService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/serverless-function/services/update-serverless-function-action-handler.service';
+import { CreateLogicFunctionActionHandlerService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/logic-function/services/create-logic-function-action-handler.service';
+import { DeleteLogicFunctionActionHandlerService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/logic-function/services/delete-logic-function-action-handler.service';
+import { UpdateLogicFunctionActionHandlerService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/logic-function/services/update-logic-function-action-handler.service';
 import { CreateSkillActionHandlerService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/skill/services/create-skill-action-handler.service';
 import { DeleteSkillActionHandlerService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/skill/services/delete-skill-action-handler.service';
 import { CreateFrontComponentActionHandlerService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/front-component/services/create-front-component-action-handler.service';
@@ -104,9 +104,9 @@ import { FunctionBuildModule } from 'src/engine/metadata-modules/function-build/
     UpdateViewGroupActionHandlerService,
     DeleteViewGroupActionHandlerService,
 
-    CreateServerlessFunctionActionHandlerService,
-    DeleteServerlessFunctionActionHandlerService,
-    UpdateServerlessFunctionActionHandlerService,
+    CreateLogicFunctionActionHandlerService,
+    DeleteLogicFunctionActionHandlerService,
+    UpdateLogicFunctionActionHandlerService,
 
     CreateRoleActionHandlerService,
     UpdateRoleActionHandlerService,

packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/utils/optimistically-apply-create-action-on-all-flat-entity-maps.util.ts

@@ -58,7 +58,7 @@ export const optimisticallyApplyCreateActionOnAllFlatEntityMaps = <
     case 'rowLevelPermissionPredicateGroup':
     case 'viewFilterGroup':
     case 'index':
-    case 'serverlessFunction':
+    case 'logicFunction':
     case 'viewFilter':
     case 'role':
     case 'roleTarget':

packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/utils/optimistically-apply-delete-action-on-all-flat-entity-maps.util.ts

@@ -35,7 +35,7 @@ export const optimisticallyApplyDeleteActionOnAllFlatEntityMaps = <
     case 'rowLevelPermissionPredicateGroup':
     case 'viewFilterGroup':
     case 'index':
-    case 'serverlessFunction':
+    case 'logicFunction':
     case 'viewFilter':
     case 'role':
     case 'roleTarget':

packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/utils/optimistically-apply-update-action-on-all-flat-entity-maps.util.ts

@@ -57,7 +57,7 @@ export const optimisticallyApplyUpdateActionOnAllFlatEntityMaps = <
     case 'rowLevelPermissionPredicate':
     case 'rowLevelPermissionPredicateGroup':
     case 'viewFilterGroup':
-    case 'serverlessFunction':
+    case 'logicFunction':
     case 'viewFilter':
     case 'role':
     case 'roleTarget':