13058 workflow with code fail to run (#13118)

- update publishOneServerlessFunction so it does not break the workflow
if failing
- update upgrade documentation to update `docker-compose.yml` when
mutated

Fixes https://github.com/twentyhq/twenty/issues/13058

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

@@ -163,7 +163,7 @@ export class ServerlessFunctionResolver {
     try {
       const { id } = input;
 
-      return await this.serverlessFunctionService.publishOneServerlessFunction(
+      return await this.serverlessFunctionService.publishOneServerlessFunctionOrFail(
         id,
         workspaceId,
       );

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

@@ -30,6 +30,10 @@ import {
   ServerlessFunctionException,
   ServerlessFunctionExceptionCode,
 } from 'src/engine/metadata-modules/serverless-function/serverless-function.exception';
+import {
+  WorkflowVersionStepException,
+  WorkflowVersionStepExceptionCode,
+} from 'src/modules/workflow/common/exceptions/workflow-version-step.exception';
 
 @Injectable()
 export class ServerlessFunctionService {
@@ -137,7 +141,7 @@ export class ServerlessFunctionService {
     return resultServerlessFunction;
   }
 
-  async publishOneServerlessFunction(id: string, workspaceId: string) {
+  async publishOneServerlessFunctionOrFail(id: string, workspaceId: string) {
     const existingServerlessFunction =
       await this.serverlessFunctionRepository.findOneOrFail({
         where: {
@@ -159,10 +163,7 @@ export class ServerlessFunctionService {
       );
 
       if (deepEqual(latestCode, draftCode)) {
-        throw new ServerlessFunctionException(
-          'Cannot publish a new version when code has not changed',
-          ServerlessFunctionExceptionCode.SERVERLESS_FUNCTION_CODE_UNCHANGED,
-        );
+        return existingServerlessFunction;
       }
     }
 
@@ -174,6 +175,7 @@ export class ServerlessFunctionService {
       serverlessFunction: existingServerlessFunction,
       version: 'draft',
     });
+
     const newFolderPath = getServerlessFolder({
       serverlessFunction: existingServerlessFunction,
       version: newVersion,
@@ -197,9 +199,26 @@ export class ServerlessFunctionService {
       },
     );
 
-    return this.serverlessFunctionRepository.findOneBy({
-      id: existingServerlessFunction.id,
-    });
+    const publishedServerlessFunction =
+      await this.serverlessFunctionRepository.findOneOrFail({
+        where: {
+          id,
+          workspaceId,
+        },
+      });
+
+    // This check should never be thrown, but we encounter some issue with
+    // publishing serverless function in self hosted instances
+    // See https://github.com/twentyhq/twenty/issues/13058
+    // TODO: remove this check when issue solved
+    if (!isDefined(publishedServerlessFunction.latestVersion)) {
+      throw new WorkflowVersionStepException(
+        `Fail to publish serverlessFunction ${publishedServerlessFunction.id}.Received latest version ${publishedServerlessFunction.latestVersion}`,
+        WorkflowVersionStepExceptionCode.FAILURE,
+      );
+    }
+
+    return publishedServerlessFunction;
   }
 
   async deleteOneServerlessFunction({

packages/twenty-server/src/modules/workflow/workflow-status/jobs/__tests__/workflow-statuses-update.job.spec.ts

@@ -50,7 +50,7 @@ describe('WorkflowStatusesUpdate', () => {
   };
 
   const mockServerlessFunctionService = {
-    publishOneServerlessFunction: jest.fn(),
+    publishOneServerlessFunctionOrFail: jest.fn(),
     findOneOrFail: jest.fn(),
   };
 
@@ -256,6 +256,9 @@ describe('WorkflowStatusesUpdate', () => {
         mockServerlessFunctionService.findOneOrFail.mockResolvedValue(
           mockServerlessFunction,
         );
+        mockServerlessFunctionService.publishOneServerlessFunctionOrFail.mockResolvedValue(
+          mockServerlessFunction,
+        );
 
         await job.handle(event);
 
@@ -264,7 +267,7 @@ describe('WorkflowStatusesUpdate', () => {
           mockWorkflowVersionRepository.findOneOrFail,
         ).toHaveBeenCalledTimes(1);
         expect(
-          mockServerlessFunctionService.publishOneServerlessFunction,
+          mockServerlessFunctionService.publishOneServerlessFunctionOrFail,
         ).toHaveBeenCalledWith('serverless-1', '1');
         expect(mockWorkflowVersionRepository.update).toHaveBeenCalledWith('1', {
           steps: [

packages/twenty-server/src/modules/workflow/workflow-status/jobs/workflow-statuses-update.job.ts

@@ -11,7 +11,6 @@ import { Processor } from 'src/engine/core-modules/message-queue/decorators/proc
 import { MessageQueue } from 'src/engine/core-modules/message-queue/message-queue.constants';
 import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
 import { ServerlessFunctionEntity } from 'src/engine/metadata-modules/serverless-function/serverless-function.entity';
-import { ServerlessFunctionExceptionCode } from 'src/engine/metadata-modules/serverless-function/serverless-function.exception';
 import { ServerlessFunctionService } from 'src/engine/metadata-modules/serverless-function/serverless-function.service';
 import { WorkspaceRepository } from 'src/engine/twenty-orm/repository/workspace.repository';
 import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
@@ -198,33 +197,11 @@ export class WorkflowStatusesUpdateJob {
         const newStep = { ...step };
 
         if (step.type === WorkflowActionType.CODE) {
-          try {
-            await this.serverlessFunctionService.publishOneServerlessFunction(
+          const serverlessFunction =
+            await this.serverlessFunctionService.publishOneServerlessFunctionOrFail(
               step.settings.input.serverlessFunctionId,
               workspaceId,
             );
-          } catch (e) {
-            // publishOneServerlessFunction throws if no change have been
-            // applied between draft and lastPublished version.
-            // If no change have been applied, we just use the same
-            // serverless function version
-            if (
-              e.code !==
-              ServerlessFunctionExceptionCode.SERVERLESS_FUNCTION_CODE_UNCHANGED
-            ) {
-              this.logger.error(
-                `Error while publishing serverless function '${step.settings.input.serverlessFunctionId}': ${e}`,
-              );
-            }
-          }
-
-          const serverlessFunction =
-            await this.serverlessFunctionRepository.findOneOrFail({
-              where: {
-                id: step.settings.input.serverlessFunctionId,
-                workspaceId,
-              },
-            });
 
           const newStepSettings = { ...step.settings };
 
@@ -233,6 +210,7 @@ export class WorkflowStatusesUpdateJob {
 
           newStep.settings = newStepSettings;
         }
+
         newSteps.push(newStep);
       }