Allow AI to update code steps (#17761)

https://github.com/user-attachments/assets/35ac5c23-4d5c-4c86-8233-7b58fbeb5a27 - add tool - move resolver code into a service --------- Co-authored-by: Félix Malfait <felix.malfait@gmail.com>
2026-02-09 15:40:44 +00:00
parent 4ae375308f
commit 2a76e1791e
11 changed files with 398 additions and 187 deletions
@@ -3,6 +3,7 @@ import { TypeOrmModule } from '@nestjs/typeorm';

 import { NestjsQueryTypeOrmModule } from '@ptc-org/nestjs-query-typeorm';

+import { ApplicationLayerModule } from 'src/engine/core-modules/application-layer/application-layer.module';
 import { ApplicationEntity } from 'src/engine/core-modules/application/application.entity';
 import { ApplicationModule } from 'src/engine/core-modules/application/application.module';
 import { AuditModule } from 'src/engine/core-modules/audit/audit.module';
@@ -18,11 +19,11 @@ import { LogicFunctionLayerModule } from 'src/engine/metadata-modules/logic-func
 import { LogicFunctionEntity } from 'src/engine/metadata-modules/logic-function/logic-function.entity';
 import { LogicFunctionResolver } from 'src/engine/metadata-modules/logic-function/logic-function.resolver';
 import { LogicFunctionMetadataService } from 'src/engine/metadata-modules/logic-function/services/logic-function-metadata.service';
+import { LogicFunctionService } from 'src/engine/metadata-modules/logic-function/services/logic-function.service';
 import { WorkspaceFlatLogicFunctionMapCacheService } from 'src/engine/metadata-modules/logic-function/services/workspace-flat-logic-function-map-cache.service';
 import { PermissionsModule } from 'src/engine/metadata-modules/permissions/permissions.module';
 import { SubscriptionsModule } from 'src/engine/subscriptions/subscriptions.module';
 import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspace-migration/workspace-migration.module';
-import { ApplicationLayerModule } from 'src/engine/core-modules/application-layer/application-layer.module';

@Module({
  imports: [
@@ -45,9 +46,10 @@ import { ApplicationLayerModule } from 'src/engine/core-modules/application-laye
  ],
  providers: [
    LogicFunctionMetadataService,
+    LogicFunctionService,
    LogicFunctionResolver,
    WorkspaceFlatLogicFunctionMapCacheService,
  ],
-  exports: [LogicFunctionMetadataService],
+  exports: [LogicFunctionMetadataService, LogicFunctionService],
 })
 export class LogicFunctionModule {}
@@ -4,18 +4,15 @@ 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 { 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 { CreateDefaultLogicFunctionInput } from 'src/engine/metadata-modules/logic-function/dtos/create-default-logic-function.input';
 import { ExecuteOneLogicFunctionInput } from 'src/engine/metadata-modules/logic-function/dtos/execute-logic-function.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';
@@ -23,16 +20,10 @@ import { LogicFunctionLogsDTO } from 'src/engine/metadata-modules/logic-function
 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 { 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 { LogicFunctionService } from 'src/engine/metadata-modules/logic-function/services/logic-function.service';
 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,
@@ -44,13 +35,8 @@ import { CreateDefaultLogicFunctionInput } from 'src/engine/metadata-modules/log
@UseFilters(PreventNestToAutoLogGraphqlErrorsFilter)
 export class LogicFunctionResolver {
  constructor(
-    private readonly logicFunctionExecutorService: LogicFunctionExecutorService,
-    private readonly logicFunctionMetadataService: LogicFunctionMetadataService,
-    private readonly logicFunctionResourceService: LogicFunctionResourceService,
-    private readonly applicationService: ApplicationService,
-    private readonly applicationLayerService: ApplicationLayerService,
+    private readonly logicFunctionService: LogicFunctionService,
    private readonly subscriptionService: SubscriptionService,
-    private readonly flatEntityMapsCacheService: WorkspaceManyOrAllFlatEntityMapsCacheService,
  ) {}

  @Query(() => LogicFunctionDTO)
@@ -59,22 +45,7 @@ export class LogicFunctionResolver {
    @AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
  ): Promise<LogicFunctionDTO> {
    try {
-      const { flatLogicFunctionMaps } =
-        await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
-          {
-            workspaceId,
-            flatMapsKeys: ['flatLogicFunctionMaps'],
-          },
-        );
-
-      const flatLogicFunction = findFlatLogicFunctionOrThrow({
-        id,
-        flatLogicFunctionMaps,
-      });
-
-      return fromFlatLogicFunctionToLogicFunctionDto({
-        flatLogicFunction,
-      });
+      return await this.logicFunctionService.findOne({ id, workspaceId });
    } catch (error) {
      return logicFunctionGraphQLApiExceptionHandler(error);
    }
@@ -85,25 +56,7 @@ export class LogicFunctionResolver {
    @AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
  ): Promise<LogicFunctionDTO[]> {
    try {
-      const { flatLogicFunctionMaps } =
-        await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
-          {
-            workspaceId,
-            flatMapsKeys: ['flatLogicFunctionMaps'],
-          },
-        );
-
-      return Object.values(flatLogicFunctionMaps.byUniversalIdentifier)
-        .filter(
-          (flatLogicFunction): flatLogicFunction is FlatLogicFunction =>
-            isDefined(flatLogicFunction) &&
-            !isDefined(flatLogicFunction.deletedAt),
-        )
-        .map((flatLogicFunction) =>
-          fromFlatLogicFunctionToLogicFunctionDto({
-            flatLogicFunction,
-          }),
-        );
+      return await this.logicFunctionService.findMany({ workspaceId });
    } catch (error) {
      return logicFunctionGraphQLApiExceptionHandler(error);
    }
@@ -115,8 +68,8 @@ export class LogicFunctionResolver {
    @AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
  ) {
    try {
-      return await this.applicationLayerService.getAvailablePackages({
-        logicFunctionId: id,
+      return await this.logicFunctionService.getAvailablePackages({
+        id,
        workspaceId,
      });
    } catch (error) {
@@ -127,19 +80,11 @@ export class LogicFunctionResolver {
  @Mutation(() => LogicFunctionDTO)
  @UseGuards(SettingsPermissionGuard(PermissionFlagType.WORKFLOWS))
  async deleteOneLogicFunction(
-    @Args('input') input: LogicFunctionIdInput,
+    @Args('input') { id }: LogicFunctionIdInput,
    @AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
  ): Promise<LogicFunctionDTO> {
    try {
-      const flatLogicFunction =
-        await this.logicFunctionMetadataService.destroyOne({
-          id: input.id,
-          workspaceId,
-        });
-
-      return fromFlatLogicFunctionToLogicFunctionDto({
-        flatLogicFunction,
-      });
+      return await this.logicFunctionService.deleteOne({ id, workspaceId });
    } catch (error) {
      return logicFunctionGraphQLApiExceptionHandler(error);
    }
@@ -148,44 +93,13 @@ export class LogicFunctionResolver {
  @Mutation(() => LogicFunctionDTO)
  @UseGuards(SettingsPermissionGuard(PermissionFlagType.WORKFLOWS))
  async createDefaultLogicFunction(
-    @Args('input')
-    input: CreateDefaultLogicFunctionInput,
+    @Args('input') input: CreateDefaultLogicFunctionInput,
    @AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
  ): Promise<LogicFunctionDTO> {
    try {
-      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,
+      return await this.logicFunctionService.createDefault({
+        input,
+        workspaceId,
      });
    } catch (error) {
      return logicFunctionGraphQLApiExceptionHandler(error);
@@ -198,48 +112,13 @@ 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.logicFunctionResourceService.buildFromSource({
-            workspaceId,
-            applicationUniversalIdentifier,
-            sourceHandlerPath: flatLogicFunction.sourceHandlerPath,
-            builtHandlerPath: flatLogicFunction.builtHandlerPath,
-          });
-
-        await this.logicFunctionMetadataService.updateChecksum({
-          id,
-          checksum,
-          workspaceId,
-        });
-      }
-
-      const result = await this.logicFunctionExecutorService.execute({
-        logicFunctionId: id,
-        workspaceId,
+      return await this.logicFunctionService.executeOne({
+        id,
        payload,
+        forceRebuild,
+        workspaceId,
      });
-
-      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);
    }
@@ -251,13 +130,9 @@ export class LogicFunctionResolver {
    @AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
  ) {
    try {
-      const { flatLogicFunction, applicationUniversalIdentifier } =
-        await this.getLogicFunctionContext({ id, workspaceId });
-
-      return this.logicFunctionResourceService.getSourceCode({
+      return await this.logicFunctionService.getSourceCode({
+        id,
        workspaceId,
-        applicationUniversalIdentifier,
-        sourceHandlerPath: flatLogicFunction.sourceHandlerPath,
      });
    } catch (error) {
      return logicFunctionGraphQLApiExceptionHandler(error);
@@ -271,14 +146,10 @@ export class LogicFunctionResolver {
    @AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
  ): Promise<boolean> {
    try {
-      const { flatLogicFunction, applicationUniversalIdentifier } =
-        await this.getLogicFunctionContext({ id, workspaceId });
-
-      await this.logicFunctionResourceService.updateSourceFiles({
-        workspaceId,
-        applicationUniversalIdentifier,
-        sourceHandlerPath: flatLogicFunction.sourceHandlerPath,
+      await this.logicFunctionService.updateLogicFunctionSource({
+        id,
        code,
+        workspaceId,
      });

      return true;
@@ -330,34 +201,4 @@ 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,
-    };
-  }
 }
@@ -0,0 +1,267 @@
+import { Injectable } from '@nestjs/common';
+
+import { Sources } from 'twenty-shared/types';
+import { isDefined } from 'twenty-shared/utils';
+import { v4 } from 'uuid';
+
+import { ApplicationLayerService } from 'src/engine/core-modules/application-layer/application-layer.service';
+import { ApplicationService } from 'src/engine/core-modules/application/services/application.service';
+import { LogicFunctionExecutorService } from 'src/engine/core-modules/logic-function/logic-function-executor/logic-function-executor.service';
+import { LogicFunctionResourceService } from 'src/engine/core-modules/logic-function/logic-function-resource/logic-function-resource.service';
+import { WorkspaceManyOrAllFlatEntityMapsCacheService } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.service';
+import { CreateDefaultLogicFunctionInput } from 'src/engine/metadata-modules/logic-function/dtos/create-default-logic-function.input';
+import { LogicFunctionExecutionResultDTO } from 'src/engine/metadata-modules/logic-function/dtos/logic-function-execution-result.dto';
+import { LogicFunctionDTO } from 'src/engine/metadata-modules/logic-function/dtos/logic-function.dto';
+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';
+
+@Injectable()
+export class LogicFunctionService {
+  constructor(
+    private readonly logicFunctionExecutorService: LogicFunctionExecutorService,
+    private readonly logicFunctionMetadataService: LogicFunctionMetadataService,
+    private readonly logicFunctionResourceService: LogicFunctionResourceService,
+    private readonly applicationService: ApplicationService,
+    private readonly applicationLayerService: ApplicationLayerService,
+    private readonly flatEntityMapsCacheService: WorkspaceManyOrAllFlatEntityMapsCacheService,
+  ) {}
+
+  async findOne({
+    id,
+    workspaceId,
+  }: {
+    id: string;
+    workspaceId: string;
+  }): Promise<LogicFunctionDTO> {
+    const { flatLogicFunctionMaps } =
+      await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
+        {
+          workspaceId,
+          flatMapsKeys: ['flatLogicFunctionMaps'],
+        },
+      );
+
+    const flatLogicFunction = findFlatLogicFunctionOrThrow({
+      id,
+      flatLogicFunctionMaps,
+    });
+
+    return fromFlatLogicFunctionToLogicFunctionDto({ flatLogicFunction });
+  }
+
+  async findMany({
+    workspaceId,
+  }: {
+    workspaceId: string;
+  }): Promise<LogicFunctionDTO[]> {
+    const { flatLogicFunctionMaps } =
+      await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
+        {
+          workspaceId,
+          flatMapsKeys: ['flatLogicFunctionMaps'],
+        },
+      );
+
+    return Object.values(flatLogicFunctionMaps.byUniversalIdentifier)
+      .filter(
+        (flatLogicFunction): flatLogicFunction is FlatLogicFunction =>
+          isDefined(flatLogicFunction) &&
+          !isDefined(flatLogicFunction.deletedAt),
+      )
+      .map((flatLogicFunction) =>
+        fromFlatLogicFunctionToLogicFunctionDto({ flatLogicFunction }),
+      );
+  }
+
+  async getAvailablePackages({
+    id,
+    workspaceId,
+  }: {
+    id: string;
+    workspaceId: string;
+  }) {
+    return this.applicationLayerService.getAvailablePackages({
+      logicFunctionId: id,
+      workspaceId,
+    });
+  }
+
+  async deleteOne({
+    id,
+    workspaceId,
+  }: {
+    id: string;
+    workspaceId: string;
+  }): Promise<LogicFunctionDTO> {
+    const flatLogicFunction =
+      await this.logicFunctionMetadataService.destroyOne({
+        id,
+        workspaceId,
+      });
+
+    return fromFlatLogicFunctionToLogicFunctionDto({ flatLogicFunction });
+  }
+
+  async createDefault({
+    input,
+    workspaceId,
+  }: {
+    input: CreateDefaultLogicFunctionInput;
+    workspaceId: string;
+  }): Promise<LogicFunctionDTO> {
+    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 });
+  }
+
+  // TODO: remove forceRebuild parameter and add a column called shouldRebuild or isBuiltUpToDate
+  async executeOne({
+    id,
+    payload,
+    forceRebuild,
+    workspaceId,
+  }: {
+    id: string;
+    payload: object;
+    forceRebuild?: boolean;
+    workspaceId: string;
+  }): Promise<LogicFunctionExecutionResultDTO> {
+    if (forceRebuild) {
+      const { flatLogicFunction, applicationUniversalIdentifier } =
+        await this.getLogicFunctionContext({ id, workspaceId });
+
+      const { checksum } =
+        await this.logicFunctionResourceService.buildFromSource({
+          workspaceId,
+          applicationUniversalIdentifier,
+          sourceHandlerPath: flatLogicFunction.sourceHandlerPath,
+          builtHandlerPath: flatLogicFunction.builtHandlerPath,
+        });
+
+      await this.logicFunctionMetadataService.updateChecksum({
+        id,
+        checksum,
+        workspaceId,
+      });
+    }
+
+    const result = await this.logicFunctionExecutorService.execute({
+      logicFunctionId: 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,
+    };
+  }
+
+  async getSourceCode({
+    id,
+    workspaceId,
+  }: {
+    id: string;
+    workspaceId: string;
+  }): Promise<Sources | null> {
+    const { flatLogicFunction, applicationUniversalIdentifier } =
+      await this.getLogicFunctionContext({ id, workspaceId });
+
+    return this.logicFunctionResourceService.getSourceCode({
+      workspaceId,
+      applicationUniversalIdentifier,
+      sourceHandlerPath: flatLogicFunction.sourceHandlerPath,
+    });
+  }
+
+  async updateLogicFunctionSource({
+    id,
+    code,
+    workspaceId,
+  }: {
+    id: string;
+    code: Sources;
+    workspaceId: string;
+  }): Promise<void> {
+    const { flatLogicFunction, applicationUniversalIdentifier } =
+      await this.getLogicFunctionContext({ id, workspaceId });
+
+    await this.logicFunctionResourceService.updateSourceFiles({
+      workspaceId,
+      applicationUniversalIdentifier,
+      sourceHandlerPath: flatLogicFunction.sourceHandlerPath,
+      code,
+    });
+  }
+
+  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,
+    };
+  }
+}