Remove versions from logicFunction (#17540)

## Summary

- Remove `latestVersion` and `publishedVersions` columns from
`LogicFunction` entity
- Remove version parameter from logic function execution, build, and
source code retrieval
- Update all related services, DTOs, utilities, and tests
- Add database migration to drop the version columns

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

@@ -1,14 +1,12 @@
 import { Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 
-import deepEqual from 'deep-equal';
 import {
   DEFAULT_API_KEY_NAME,
   DEFAULT_API_URL_NAME,
 } from 'twenty-shared/application';
 import { isDefined } from 'twenty-shared/utils';
 import { Repository } from 'typeorm';
-import { FileFolder } from 'twenty-shared/types';
 
 import { FileStorageExceptionCode } from 'src/engine/core-modules/file-storage/interfaces/file-storage-exception';
 import { type LogicFunctionExecuteResult } from 'src/engine/core-modules/logic-function-executor/drivers/interfaces/logic-function-executor-driver.interface';
@@ -26,7 +24,6 @@ import { ThrottlerService } from 'src/engine/core-modules/throttler/throttler.se
 import { TwentyConfigService } from 'src/engine/core-modules/twenty-config/twenty-config.service';
 import { WorkspaceManyOrAllFlatEntityMapsCacheService } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.service';
 import { findFlatEntityByIdInFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps-or-throw.util';
-import { findFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps.util';
 import { LogicFunctionLayerService } from 'src/engine/metadata-modules/logic-function-layer/logic-function-layer.service';
 import { CreateLogicFunctionInput } from 'src/engine/metadata-modules/logic-function/dtos/create-logic-function.input';
 import { type UpdateLogicFunctionInput } from 'src/engine/metadata-modules/logic-function/dtos/update-logic-function.input';
@@ -44,10 +41,6 @@ import { SubscriptionService } from 'src/engine/subscriptions/subscription.servi
 import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
 import { WorkspaceMigrationBuilderException } from 'src/engine/workspace-manager/workspace-migration/exceptions/workspace-migration-builder-exception';
 import { WorkspaceMigrationValidateBuildAndRunService } from 'src/engine/workspace-manager/workspace-migration/services/workspace-migration-validate-build-and-run-service';
-import {
-  WorkflowVersionStepException,
-  WorkflowVersionStepExceptionCode,
-} from 'src/modules/workflow/common/exceptions/workflow-version-step.exception';
 import { cleanServerUrl } from 'src/utils/clean-server-url';
 import { FunctionBuildService } from 'src/engine/metadata-modules/function-build/function-build.service';
 
@@ -74,35 +67,7 @@ export class LogicFunctionService {
     private readonly secretEncryptionService: SecretEncryptionService,
   ) {}
 
-  async hasLogicFunctionPublishedVersion(
-    logicFunctionId: string,
-    workspaceId: string,
-  ) {
-    const { flatLogicFunctionMaps } =
-      await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
-        {
-          workspaceId,
-          flatMapsKeys: ['flatLogicFunctionMaps'],
-        },
-      );
-
-    const flatLogicFunction = findFlatEntityByIdInFlatEntityMaps({
-      flatEntityId: logicFunctionId,
-      flatEntityMaps: flatLogicFunctionMaps,
-    });
-
-    return (
-      isDefined(flatLogicFunction) &&
-      !isDefined(flatLogicFunction.deletedAt) &&
-      isDefined(flatLogicFunction.latestVersion)
-    );
-  }
-
-  async getLogicFunctionSourceCode(
-    workspaceId: string,
-    id: string,
-    version: string,
-  ) {
+  async getLogicFunctionSourceCode(workspaceId: string, id: string) {
     const { flatLogicFunctionMaps } =
       await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
         {
@@ -119,7 +84,6 @@ export class LogicFunctionService {
     try {
       const folderPath = getLogicFunctionFolderOrThrow({
         flatLogicFunction,
-        version,
       });
 
       return await this.fileStorageService.readFolder(folderPath);
@@ -135,12 +99,10 @@ export class LogicFunctionService {
     id,
     workspaceId,
     payload,
-    version = 'latest',
   }: {
     id: string;
     workspaceId: string;
     payload: object;
-    version?: string;
   }): Promise<LogicFunctionExecuteResult> {
     await this.throttleExecution(workspaceId);
 
@@ -208,12 +170,10 @@ export class LogicFunctionService {
     if (
       !(await this.functionBuildService.isBuilt({
         flatLogicFunction,
-        version,
       }))
     ) {
       await this.functionBuildService.buildAndUpload({
         flatLogicFunction,
-        version,
       });
     }
 
@@ -223,7 +183,6 @@ export class LogicFunctionService {
           flatLogicFunction,
           flatLogicFunctionLayer,
           payload,
-          version,
           env: envVariables,
         }),
       timeoutMs: flatLogicFunction.timeoutSeconds * 1000,
@@ -290,116 +249,7 @@ export class LogicFunctionService {
       flatLogicFunctionMaps,
     });
 
-    if (isDefined(existingFlatLogicFunction.latestVersion)) {
-      const latestCode = await this.getLogicFunctionSourceCode(
-        workspaceId,
-        id,
-        'latest',
-      );
-      const draftCode = await this.getLogicFunctionSourceCode(
-        workspaceId,
-        id,
-        'draft',
-      );
-
-      if (deepEqual(latestCode, draftCode)) {
-        return existingFlatLogicFunction;
-      }
-    }
-
-    const newVersion = existingFlatLogicFunction.latestVersion
-      ? `${parseInt(existingFlatLogicFunction.latestVersion, 10) + 1}`
-      : '1';
-
-    const draftSourceFolderPath = getLogicFunctionFolderOrThrow({
-      flatLogicFunction: existingFlatLogicFunction,
-      version: 'draft',
-      fileFolder: FileFolder.LogicFunction,
-    });
-
-    const newSourceFolderPath = getLogicFunctionFolderOrThrow({
-      flatLogicFunction: existingFlatLogicFunction,
-      version: newVersion,
-      fileFolder: FileFolder.LogicFunction,
-    });
-
-    await this.fileStorageService.copy({
-      from: { folderPath: draftSourceFolderPath },
-      to: { folderPath: newSourceFolderPath },
-    });
-
-    const draftBuiltFolderPath = getLogicFunctionFolderOrThrow({
-      flatLogicFunction: existingFlatLogicFunction,
-      version: 'draft',
-      fileFolder: FileFolder.BuiltFunction,
-    });
-
-    const newBuiltFolderPath = getLogicFunctionFolderOrThrow({
-      flatLogicFunction: existingFlatLogicFunction,
-      version: newVersion,
-      fileFolder: FileFolder.BuiltFunction,
-    });
-
-    await this.fileStorageService.copy({
-      from: { folderPath: draftBuiltFolderPath },
-      to: { folderPath: newBuiltFolderPath },
-    });
-
-    const newPublishedVersions = [
-      ...existingFlatLogicFunction.publishedVersions,
-      newVersion,
-    ];
-
-    const updatedFlatLogicFunction: FlatLogicFunction = {
-      ...existingFlatLogicFunction,
-      latestVersion: newVersion,
-      publishedVersions: newPublishedVersions,
-    };
-
-    const validateAndBuildResult =
-      await this.workspaceMigrationValidateBuildAndRunService.validateBuildAndRunWorkspaceMigration(
-        {
-          allFlatEntityOperationByMetadataName: {
-            logicFunction: {
-              flatEntityToCreate: [],
-              flatEntityToDelete: [],
-              flatEntityToUpdate: [updatedFlatLogicFunction],
-            },
-          },
-          workspaceId,
-          isSystemBuild: false,
-        },
-      );
-
-    if (isDefined(validateAndBuildResult)) {
-      throw new WorkspaceMigrationBuilderException(
-        validateAndBuildResult,
-        'Multiple validation errors occurred while publishing logic function',
-      );
-    }
-
-    const { flatLogicFunctionMaps: recomputedFlatLogicFunctionMaps } =
-      await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
-        {
-          workspaceId,
-          flatMapsKeys: ['flatLogicFunctionMaps'],
-        },
-      );
-
-    const publishedFlatLogicFunction =
-      findFlatEntityByIdInFlatEntityMapsOrThrow({
-        flatEntityId: id,
-        flatEntityMaps: recomputedFlatLogicFunctionMaps,
-      });
-
-    if (!isDefined(publishedFlatLogicFunction.latestVersion)) {
-      throw new WorkflowVersionStepException(
-        `Fail to publish logicFunction ${publishedFlatLogicFunction.id}.Received latest version ${publishedFlatLogicFunction.latestVersion}`,
-        WorkflowVersionStepExceptionCode.CODE_STEP_FAILURE,
-      );
-    }
-
-    return publishedFlatLogicFunction;
+    return existingFlatLogicFunction;
   }
 
   async deleteOneLogicFunction({
@@ -700,55 +550,11 @@ export class LogicFunctionService {
     });
   }
 
-  async createDraftFromPublishedVersion({
-    id,
-    version,
-    workspaceId,
-  }: {
-    id: string;
-    version: string;
-    workspaceId: string;
-  }) {
-    if (version === 'draft') {
-      return;
-    }
-
-    const { flatLogicFunctionMaps } =
-      await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
-        {
-          workspaceId,
-          flatMapsKeys: ['flatLogicFunctionMaps'],
-        },
-      );
-
-    const flatLogicFunction = findFlatLogicFunctionOrThrow({
-      id,
-      flatLogicFunctionMaps,
-    });
-
-    await this.fileStorageService.copy({
-      from: {
-        folderPath: getLogicFunctionFolderOrThrow({
-          flatLogicFunction,
-          version,
-        }),
-      },
-      to: {
-        folderPath: getLogicFunctionFolderOrThrow({
-          flatLogicFunction,
-          version: 'draft',
-        }),
-      },
-    });
-  }
-
   async duplicateLogicFunction({
     id,
-    version,
     workspaceId,
   }: {
     id: string;
-    version: string;
     workspaceId: string;
   }): Promise<FlatLogicFunction> {
     const { flatLogicFunctionMaps } =
@@ -779,13 +585,11 @@ export class LogicFunctionService {
       from: {
         folderPath: getLogicFunctionFolderOrThrow({
           flatLogicFunction: flatLogicFunctionToDuplicate,
-          version,
         }),
       },
       to: {
         folderPath: getLogicFunctionFolderOrThrow({
           flatLogicFunction: newFlatLogicFunction,
-          version: 'draft',
         }),
       },
     });