Reorganize logic function files (#17766)

reorganize according to

<img width="1243" height="725" alt="Pasted Graphic"
src="https://github.com/user-attachments/assets/ba65dd10-8eec-4b13-ad49-9726edd3b79c"
/>

Not working yet

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

@@ -4,34 +4,35 @@ import { Args, Mutation, Query, Resolver, Subscription } from '@nestjs/graphql';
 import graphqlTypeJson from 'graphql-type-json';
 import { PermissionFlagType } from 'twenty-shared/constants';
 import { isDefined } from 'twenty-shared/utils';
+import { v4 } from 'uuid';
 
 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 { LogicFunctionResourceService } from 'src/engine/core-modules/logic-function/logic-function-resource/logic-function-resource.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';
 import { SettingsPermissionGuard } from 'src/engine/guards/settings-permission.guard';
 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 { 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 { 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 { LogicFunctionMetadataService } from 'src/engine/metadata-modules/logic-function/services/logic-function-metadata.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';
 import { fromFlatLogicFunctionToLogicFunctionDto } from 'src/engine/metadata-modules/logic-function/utils/from-flat-logic-function-to-logic-function-dto.util';
 import { logicFunctionGraphQLApiExceptionHandler } from 'src/engine/metadata-modules/logic-function/utils/logic-function-graphql-api-exception-handler.utils';
 import { SubscriptionChannel } from 'src/engine/subscriptions/enums/subscription-channel.enum';
 import { SubscriptionService } from 'src/engine/subscriptions/subscription.service';
+import { LogicFunctionExecutorService } from 'src/engine/core-modules/logic-function/logic-function-executor/logic-function-executor.service';
+import { ApplicationLayerService } from 'src/engine/core-modules/application-layer/application-layer.service';
+import { CreateDefaultLogicFunctionInput } from 'src/engine/metadata-modules/logic-function/dtos/create-default-logic-function.input';
 
 @UseGuards(
   WorkspaceAuthGuard,
@@ -43,44 +44,15 @@ import { SubscriptionService } from 'src/engine/subscriptions/subscription.servi
 @UseFilters(PreventNestToAutoLogGraphqlErrorsFilter)
 export class LogicFunctionResolver {
   constructor(
-    private readonly logicFunctionService: LogicFunctionService,
     private readonly logicFunctionExecutorService: LogicFunctionExecutorService,
-    private readonly logicFunctionSourceBuilderService: LogicFunctionSourceBuilderService,
+    private readonly logicFunctionMetadataService: LogicFunctionMetadataService,
+    private readonly logicFunctionResourceService: LogicFunctionResourceService,
     private readonly applicationService: ApplicationService,
+    private readonly applicationLayerService: ApplicationLayerService,
     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,
@@ -138,9 +110,15 @@ export class LogicFunctionResolver {
   }
 
   @Query(() => graphqlTypeJson)
-  async getAvailablePackages(@Args('input') { id }: LogicFunctionIdInput) {
+  async getAvailablePackages(
+    @Args('input') { id }: LogicFunctionIdInput,
+    @AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
+  ) {
     try {
-      return await this.logicFunctionExecutorService.getAvailablePackages(id);
+      return await this.applicationLayerService.getAvailablePackages({
+        logicFunctionId: id,
+        workspaceId,
+      });
     } catch (error) {
       return logicFunctionGraphQLApiExceptionHandler(error);
     }
@@ -153,10 +131,11 @@ export class LogicFunctionResolver {
     @AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
   ): Promise<LogicFunctionDTO> {
     try {
-      const flatLogicFunction = await this.logicFunctionService.destroyOne({
-        id: input.id,
-        workspaceId,
-      });
+      const flatLogicFunction =
+        await this.logicFunctionMetadataService.destroyOne({
+          id: input.id,
+          workspaceId,
+        });
 
       return fromFlatLogicFunctionToLogicFunctionDto({
         flatLogicFunction,
@@ -168,16 +147,42 @@ export class LogicFunctionResolver {
 
   @Mutation(() => LogicFunctionDTO)
   @UseGuards(SettingsPermissionGuard(PermissionFlagType.WORKFLOWS))
-  async createOneLogicFunction(
+  async createDefaultLogicFunction(
     @Args('input')
-    input: CreateLogicFunctionInput,
+    input: CreateDefaultLogicFunctionInput,
     @AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
   ): Promise<LogicFunctionDTO> {
     try {
-      const flatLogicFunction = await this.logicFunctionService.createOne({
-        input,
-        workspaceId,
-      });
+      const { workspaceCustomFlatApplication } =
+        await this.applicationService.findWorkspaceTwentyStandardAndCustomApplicationOrThrow(
+          {
+            workspaceId,
+          },
+        );
+
+      const logicFunctionId = input.id ?? v4();
+
+      const { sourceHandlerPath, builtHandlerPath, handlerName, checksum } =
+        await this.logicFunctionResourceService.seedSourceFiles({
+          sourceSubfolder: logicFunctionId,
+          workspaceId,
+          applicationUniversalIdentifier:
+            workspaceCustomFlatApplication.universalIdentifier,
+        });
+
+      const flatLogicFunction =
+        await this.logicFunctionMetadataService.createOne({
+          input: {
+            ...input,
+            id: logicFunctionId,
+            sourceHandlerPath,
+            builtHandlerPath,
+            handlerName,
+            checksum,
+          },
+          workspaceId,
+          ownerFlatApplication: workspaceCustomFlatApplication,
+        });
 
       return fromFlatLogicFunctionToLogicFunctionDto({
         flatLogicFunction,
@@ -193,32 +198,32 @@ export class LogicFunctionResolver {
     @Args('input') { id, payload, forceRebuild }: ExecuteOneLogicFunctionInput,
     @AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
   ): Promise<LogicFunctionExecutionResultDTO> {
+    // TODO: remove forceRebuild parameter and add a column called shouldRebuild or isBuiltUpToDate
     try {
       if (forceRebuild) {
         const { flatLogicFunction, applicationUniversalIdentifier } =
           await this.getLogicFunctionContext({ id, workspaceId });
 
         const { checksum } =
-          await this.logicFunctionSourceBuilderService.buildFromSource({
+          await this.logicFunctionResourceService.buildFromSource({
             workspaceId,
             applicationUniversalIdentifier,
             sourceHandlerPath: flatLogicFunction.sourceHandlerPath,
             builtHandlerPath: flatLogicFunction.builtHandlerPath,
           });
 
-        await this.logicFunctionService.updateChecksum({
+        await this.logicFunctionMetadataService.updateChecksum({
           id,
           checksum,
           workspaceId,
         });
       }
 
-      const result =
-        await this.logicFunctionExecutorService.executeOneLogicFunction({
-          id,
-          workspaceId,
-          payload,
-        });
+      const result = await this.logicFunctionExecutorService.execute({
+        logicFunctionId: id,
+        workspaceId,
+        payload,
+      });
 
       return {
         data: result.data as LogicFunctionExecutionResultDTO['data'],
@@ -242,14 +247,14 @@ export class LogicFunctionResolver {
 
   @Query(() => graphqlTypeJson, { nullable: true })
   async getLogicFunctionSourceCode(
-    @Args('input') { id }: GetLogicFunctionSourceCodeInput,
+    @Args('input') { id }: LogicFunctionIdInput,
     @AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
   ) {
     try {
       const { flatLogicFunction, applicationUniversalIdentifier } =
         await this.getLogicFunctionContext({ id, workspaceId });
 
-      return this.logicFunctionSourceBuilderService.getSourceCode({
+      return this.logicFunctionResourceService.getSourceCode({
         workspaceId,
         applicationUniversalIdentifier,
         sourceHandlerPath: flatLogicFunction.sourceHandlerPath,
@@ -269,7 +274,7 @@ export class LogicFunctionResolver {
       const { flatLogicFunction, applicationUniversalIdentifier } =
         await this.getLogicFunctionContext({ id, workspaceId });
 
-      await this.logicFunctionSourceBuilderService.updateSourceFiles({
+      await this.logicFunctionResourceService.updateSourceFiles({
         workspaceId,
         applicationUniversalIdentifier,
         sourceHandlerPath: flatLogicFunction.sourceHandlerPath,
@@ -325,4 +330,34 @@ export class LogicFunctionResolver {
       workspaceId: workspace.id,
     });
   }
+
+  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,
+    };
+  }
 }