feat: improve error handling and lifecycle management in Backends and LifecycleHooks services

- Enhanced error handling in BackendsService by utilizing a new function to format worker result error messages, improving clarity in BadRequestException responses.
- Updated IdentitiesCrudController to retrieve the updated identity after lifecycle changes, ensuring accurate data representation.
- Modified LifecycleHooksService to implement rollback logic on backend failures during lifecycle updates, enhancing reliability and consistency in identity state management.
- Added a new method in the web UI to extract and display lifecycle error messages, improving user feedback during lifecycle transitions.

Author: tacxou

apps/api/src/core/backends/_functions/format-worker-result-error-message.function.ts

@@ -0,0 +1,22 @@
+import { WorkerResultInterface } from '../_interfaces/worker-result.interface';
+
+export function formatWorkerResultErrorMessage(workerResult?: WorkerResultInterface): string {
+  if (!workerResult?.data) {
+    return 'Échec de synchronisation backend';
+  }
+
+  const messages: string[] = [];
+  for (const [backendName, result] of Object.entries(workerResult.data)) {
+    const message = result?.error?.message || result?.output?.message;
+    if (message) {
+      messages.push(`${backendName}: ${message}`);
+      continue;
+    }
+
+    if (result?.status) {
+      messages.push(`${backendName}: erreur (code ${result.status})`);
+    }
+  }
+
+  return messages.length ? messages.join(' · ') : 'Échec de synchronisation backend';
+}

apps/api/src/core/backends/backends.service.ts

@@ -20,6 +20,7 @@ import { TasksService } from '../tasks/tasks.service';
 import { ActionType } from './_enum/action-type.enum';
 import { ExecuteJobOptions } from './_interfaces/execute-job-options.interface';
 import { WorkerResultInterface } from '~/core/backends/_interfaces/worker-result.interface';
+import { formatWorkerResultErrorMessage } from '~/core/backends/_functions/format-worker-result-error-message.function';
 import { DataStatusEnum } from '~/management/identities/_enums/data-status';
 
 const DEFAULT_SYNC_TIMEOUT = 30_000;
@@ -672,10 +673,13 @@ export class BackendsService extends AbstractQueueProcessor {
         });
       }
 
+      const workerResult = (error as any).response as WorkerResultInterface | undefined;
+
       throw new BadRequestException({
         status: HttpStatus.BAD_REQUEST,
+        message: formatWorkerResultErrorMessage(workerResult),
         error,
-        job: (error as any).response,
+        job: workerResult,
       });
     }
 

apps/api/src/management/identities/identities-crud.controller.ts

@@ -369,7 +369,9 @@ export class IdentitiesCrudController extends AbstractController {
       }
     }
 
-    const data = await this._service.updateLifecycle(_id, body.lifecycle);
+    await this._service.updateLifecycle(_id, body.lifecycle);
+    const data = await this._service.findById<Identities>(_id);
+
     return res.status(HttpStatus.OK).json({
       statusCode: HttpStatus.OK,
       data,

apps/api/src/management/lifecycle/lifecycle-hooks.service.ts

@@ -419,7 +419,7 @@ export class LifecycleHooksService extends AbstractLifecycleService {
    * // Déclenché automatiquement lors de :
    * // await identitiesService.update(id, { lifecycle: 'MANUAL' })
    */
-  @OnEvent('management.identities.service.afterUpdate')
+  @OnEvent('management.identities.service.afterUpdate', { suppressErrors: false })
   public async handle(event: { updated: Identities; before?: Identities }): Promise<void> {
     this.logger.verbose(`Handling identity update event for identity <${event.updated._id}>`);
 
@@ -452,7 +452,7 @@ export class LifecycleHooksService extends AbstractLifecycleService {
    * // Déclenché automatiquement lors de :
    * // await identitiesService.upsert(filter, data)
    */
-  @OnEvent('management.identities.service.afterUpsert')
+  @OnEvent('management.identities.service.afterUpsert', { suppressErrors: false })
   public async handleOrderCreatedEvent(event: { result: Identities; before?: Identities }): Promise<void> {
     this.logger.verbose(`Handling identity upsert event for identity <${event.result._id}>`);
 
@@ -515,12 +515,35 @@ export class LifecycleHooksService extends AbstractLifecycleService {
     return before.lifecycle === after.lifecycle && before.state !== after.state;
   }
 
+  private async rollbackLifecycleOnBackendFailure(
+    identityId: Types.ObjectId,
+    lifecycle: string,
+    lastLifecycleUpdate: Date | undefined,
+    historyIds: Array<Types.ObjectId | string>,
+  ): Promise<void> {
+    await this.identitiesService.model.findByIdAndUpdate(identityId, {
+      $set: {
+        lifecycle,
+        ...(lastLifecycleUpdate ? { lastLifecycleUpdate } : {}),
+      },
+    });
+
+    for (const historyId of historyIds) {
+      try {
+        await this.delete(historyId);
+      } catch (error) {
+        this.logger.warn(`Unable to delete lifecycle history <${historyId}>: ${error?.message}`);
+      }
+    }
+  }
+
   private async fireLifecycleEvent(
     before: Identities,
     after: Identities,
     options?: { force?: boolean },
   ): Promise<void> {
     const lifecycleChanged = options?.force || (!!before && before.lifecycle !== after.lifecycle);
+    const shouldRollbackLifecycle = lifecycleChanged && !options?.force && !!before;
 
     if (!options?.force && this.isOperationalStateOnlyChange(before, after)) {
       this.logger.debug(
@@ -529,14 +552,15 @@ export class LifecycleHooksService extends AbstractLifecycleService {
       return;
     }
 
+    let initialHistoryId: Types.ObjectId | string | undefined;
     if (lifecycleChanged) {
-      await this.create({
+      const history = await this.create({
         refId: after._id,
         lifecycle: after.lifecycle,
         date: new Date(),
       });
+      initialHistoryId = history?._id ? String(history._id) : undefined;
       this.logger.debug(`Lifecycle event manualy recorded for identity <${after._id}>: ${after.lifecycle}`);
-      // If the lifecycle has changed, we need to process the new lifecycle
     }
 
     if (this.lifecycleSources[after.lifecycle]) {
@@ -551,7 +575,7 @@ export class LifecycleHooksService extends AbstractLifecycleService {
 
         if (lcs.trigger) {
           this.logger.debug(`Skipping lifecycle source <${after.lifecycle}> with trigger: ${lcs.trigger}`);
-          continue; // Skip processing if it's a trigger-based rule
+          continue;
         }
 
         const hasMutation = hasLifecycleMutation(resolvedMutation);
@@ -570,8 +594,8 @@ export class LifecycleHooksService extends AbstractLifecycleService {
             },
           },
           {
-            new: true, // Return the updated document
-            upsert: false, // Do not create a new document if no match is found
+            new: true,
+            upsert: false,
           },
         );
 
@@ -580,16 +604,27 @@ export class LifecycleHooksService extends AbstractLifecycleService {
           continue;
         }
 
-        await this.create({
+        const ruleHistory = await this.create({
           refId: after._id,
           lifecycle: lcs.target,
           date: new Date(),
         });
 
         const identities = res._id ? [{ id: res._id.toString(), before: after, after: res }] : [];
-        await this.backendsService.lifecycleChangedIdentities(identities, {
-          ...(hasMutation ? { targetState: IdentityState.TO_SYNC } : {}),
-        });
+
+        try {
+          await this.backendsService.lifecycleChangedIdentities(identities, {
+            ...(hasMutation ? { targetState: IdentityState.TO_SYNC } : {}),
+          });
+        } catch (error) {
+          await this.rollbackLifecycleOnBackendFailure(
+            after._id,
+            after.lifecycle,
+            after.lastLifecycleUpdate,
+            [ruleHistory?._id ? String(ruleHistory._id) : undefined].filter(Boolean) as Array<Types.ObjectId | string>,
+          );
+          throw error;
+        }
 
         this.logger.log(
           hasMutation
@@ -602,7 +637,20 @@ export class LifecycleHooksService extends AbstractLifecycleService {
 
     if (lifecycleChanged) {
       const identities = after._id ? [{ id: after._id.toString(), before, after }] : [];
-      await this.backendsService.lifecycleChangedIdentities(identities);
+
+      try {
+        await this.backendsService.lifecycleChangedIdentities(identities);
+      } catch (error) {
+        if (shouldRollbackLifecycle) {
+          await this.rollbackLifecycleOnBackendFailure(
+            after._id,
+            before.lifecycle,
+            before.lastLifecycleUpdate,
+            [initialHistoryId].filter(Boolean) as Array<Types.ObjectId | string>,
+          );
+        }
+        throw error;
+      }
     }
   }
 }

apps/api/tests/unit/core/backends/format-worker-result-error-message.function.spec.ts

@@ -0,0 +1,19 @@
+import { formatWorkerResultErrorMessage } from '~/core/backends/_functions/format-worker-result-error-message.function';
+
+describe('formatWorkerResultErrorMessage', () => {
+  it('should format backend error messages', () => {
+    const message = formatWorkerResultErrorMessage({
+      jobId: '1',
+      status: 1,
+      data: {
+        dummy: {
+          backend: 'dummy',
+          status: 1,
+          error: { status: 1, message: 'Transition P vers A refusée par dummy2' },
+        },
+      },
+    });
+
+    expect(message).toBe('dummy: Transition P vers A refusée par dummy2');
+  });
+});

apps/web/src/pages/identities/table/[_id]/index.vue

@@ -326,6 +326,24 @@ export default defineNuxtComponent({
       }
       return this.isManualLifecycleTargetAllowed(this.identity.lifecycle, targetLifecycle)
     },
+    extractLifecycleErrorMessage(error: any): string {
+      const data = error?.response?._data
+      if (typeof data?.message === 'string' && data.message.trim()) {
+        return data.message
+      }
+
+      const job = data?.job
+      if (job?.data) {
+        for (const result of Object.values(job.data) as Array<{ error?: { message?: string }; output?: { message?: string } }>) {
+          const message = result?.error?.message || result?.output?.message
+          if (message) {
+            return message
+          }
+        }
+      }
+
+      return data?.error?.message || error?.message || 'erreur inconnue'
+    },
     async switchLifecycle(lifecycle: string) {
       if (!this.isManualLifecycleChangeAllowed(lifecycle)) {
         this.$q.notify({
@@ -345,14 +363,15 @@ export default defineNuxtComponent({
           position: 'top-right',
           icon: 'mdi-check-circle-outline',
         })
-        ;(this as any).refresh()
       } catch (error: any) {
         this.$q.notify({
-          message: 'Impossible de modifier le cycle de vie : ' + error.response._data.message,
+          message: 'Impossible de modifier le cycle de vie : ' + this.extractLifecycleErrorMessage(error),
           color: 'negative',
           position: 'top-right',
           icon: 'mdi-alert-circle-outline',
         })
+      } finally {
+        ;(this as any).refresh()
       }
     },
     async forceLifecycleExecution() {