@masterteam/work-center 0.0.82 → 0.0.83

package/fesm2022/masterteam-work-center.mjs

@@ -15,8 +15,8 @@ import { SkeletonModule } from 'primeng/skeleton';
 import { catchError, EMPTY, map, take, firstValueFrom, of } from 'rxjs';
 import { ModalRef } from '@masterteam/components/dialog';
 import { DrawerController } from '@masterteam/components/dynamic-drawer';
-import { ClientForm, ClientFormWarningsDialog, ClientFormApiService } from '@masterteam/forms/client-form';
-import { HttpClient } from '@angular/common/http';
+import { ClientForm, ClientFormWarningsDialog } from '@masterteam/forms/client-form';
+import { HttpClient, HttpHeaders } from '@angular/common/http';
 import { Router, ActivatedRoute } from '@angular/router';
 import { Drawer } from '@masterteam/components/drawer';
 import { RuntimeActionContextStore, RuntimeActionRunner, RUNTIME_ACTION_CONFIRM_DIALOG, hasActionFormFields, buildActionPayload, resolveActionLabel } from '@masterteam/components/runtime-action';
@@ -1322,20 +1322,17 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.8", ngImpor
 
 /**
  * The channel between the client form in the modal body and the action footer,
- * route-scoped alongside `RuntimeActionContextStore`. It carries three things
+ * route-scoped alongside `RuntimeActionContextStore`. It carries two things
  * in both directions:
  *
- * - the form's submit context, for the validate pre-flight;
  * - whether the form is locally complete, so the footer can gate its actions;
  * - the failure messages of the last action, so they can be rendered above the
  *   form instead of squeezed beside the buttons.
  */
 class WorkCenterActionFormStore {
-    formContext = signal(null, ...(ngDevMode ? [{ debugName: "formContext" }] : /* istanbul ignore next */ []));
     formIncomplete = signal(false, ...(ngDevMode ? [{ debugName: "formIncomplete" }] : /* istanbul ignore next */ []));
     actionErrors = signal([], ...(ngDevMode ? [{ debugName: "actionErrors" }] : /* istanbul ignore next */ []));
     errorHosted = signal(false, ...(ngDevMode ? [{ debugName: "errorHosted" }] : /* istanbul ignore next */ []));
-    context = this.formContext.asReadonly();
     /**
      * True while the on-screen form fails its own local validation — a required
      * field left empty, a formula error. The footer disables the actions that
@@ -1353,9 +1350,6 @@ class WorkCenterActionFormStore {
      * claims them, so an item type with no form still reports a failure.
      */
     hasErrorHost = this.errorHosted.asReadonly();
-    setContext(context) {
-        this.formContext.set(context);
-    }
     setIncomplete(incomplete) {
         this.formIncomplete.set(incomplete);
     }
@@ -2421,22 +2415,6 @@ class WorkCenterProcessRequestType {
         effect(() => {
             this.actionContext?.setFormSource(this.readOnly() ? null : (this.clientForm() ?? null));
         });
-        // See the equivalent effect in `WorkCenterProcessStepType`. Gated on
-        // `isReadonly` rather than `readOnly`, since the request form is only
-        // editable while the request sits in `Returned`.
-        effect(() => {
-            this.formStore?.setContext(this.isReadonly() || !this.canRenderForm()
-                ? null
-                : {
-                    moduleKey: this.moduleKey(),
-                    operationKey: this.operationKey(),
-                    moduleId: this.moduleId(),
-                    levelId: this.levelId(),
-                    levelDataId: this.levelDataId(),
-                    moduleDataId: this.moduleDataId(),
-                    requestSchemaId: this.requestSchemaId(),
-                });
-        });
         // `formControl.status` is not a signal, so mirror it into one — without
         // this the footer would keep its stale enabled/disabled state while the
         // approver fills the form in.
@@ -2466,7 +2444,6 @@ class WorkCenterProcessRequestType {
     }
     ngOnDestroy() {
         this.actionContext?.setFormSource(null);
-        this.formStore?.setContext(null);
         this.formStore?.setIncomplete(false);
         this.formStore?.setErrorHost(false);
     }
@@ -2613,23 +2590,6 @@ class WorkCenterProcessStepType {
         effect(() => {
             this.actionContext?.setFormSource(this.readOnly() ? null : (this.clientForm() ?? null));
         });
-        // Publishes what the footer's `process-submit/validate` pre-flight needs.
-        // Only the editable case is published: on a read-only form the approver
-        // cannot fix anything, so blocking them on a rule failure would strand the
-        // action instead of helping.
-        effect(() => {
-            this.formStore?.setContext(this.readOnly() || !this.canRenderForm()
-                ? null
-                : {
-                    moduleKey: this.moduleKey(),
-                    operationKey: this.operationKey(),
-                    moduleId: this.moduleId(),
-                    levelId: this.levelId(),
-                    levelDataId: this.levelDataId(),
-                    moduleDataId: this.moduleDataId(),
-                    requestSchemaId: this.requestSchemaId(),
-                });
-        });
         // `formControl.status` is not a signal, so mirror it into one — without
         // this the footer would keep its stale enabled/disabled state while the
         // approver fills the form in.
@@ -2659,7 +2619,6 @@ class WorkCenterProcessStepType {
     }
     ngOnDestroy() {
         this.actionContext?.setFormSource(null);
-        this.formStore?.setContext(null);
         this.formStore?.setIncomplete(false);
         this.formStore?.setErrorHost(false);
     }
@@ -3142,18 +3101,65 @@ class WorkCenterFormValidationError extends Error {
     }
 }
 
+const FORM_VALIDATION_WARNINGS = 'FormValidationWarnings';
 /**
- * Renders what a process action's validation has to say, before it runs and
- * after it fails.
- *
- * Actions do not negotiate over warnings. A Work Center action is one HTTP
- * request: the `process-submit/validate` pre-flight asks about non-blocking
- * failures up front (`confirmWarnings`), and whatever the action itself answers
- * is final — a failure is reported, never acknowledged and retried.
+ * Renders what a process action's validation has to say, before it runs
+ * (`confirmWarnings`, driven by the pre-flight) and after it fails
+ * (`resolveErrorMessages`, `recover`).
  */
 class WorkCenterActionValidationHandler {
     modal = inject(ModalService);
+    runner = inject(RuntimeActionRunner);
     transloco = inject(TranslocoService);
+    /**
+     * Recovers the backend's `FormValidationWarnings` fallback.
+     *
+     * The backend revalidates immediately before it changes workflow state, so a
+     * clean pre-flight is not a promise: configuration or persisted values may
+     * have moved, the workflow may have advanced, or the receipt may have gone
+     * stale. When that happens the action is refused with `400` and a
+     * **replacement** token.
+     *
+     * These are warnings the user has not seen — that is the whole reason the
+     * pre-flight's answer no longer holds — so they are shown and confirmed like
+     * any other, and only then does the action go out again carrying the new
+     * token. Declining reports the action as `cancelled`, and the workflow stays
+     * where it was.
+     *
+     * `FormValidationErrors` — the blocking kind — are never recovered here.
+     */
+    async recover(action, error, submittedPayload, defaultAfterSuccess) {
+        const validationError = readProcessActionValidationError(error);
+        if (validationError?.kind !== FORM_VALIDATION_WARNINGS ||
+            !validationError.requiresAcknowledgement ||
+            !validationError.validationWarningsToken ||
+            validationError.validationWarningsToken ===
+                submittedPayload?.['validationWarningsToken']) {
+            return null;
+        }
+        const confirmed = await this.confirmWarnings(this.resolveValidationMessages(validationError));
+        if (!confirmed) {
+            return {
+                status: 'cancelled',
+                actionKey: action.actionKey,
+                afterSuccess: null,
+            };
+        }
+        const retryPayload = {
+            ...(submittedPayload ?? {}),
+            validationWarningsToken: validationError.validationWarningsToken,
+        };
+        // This descriptor is intentionally ephemeral, and the retry is a new
+        // request with its own idempotency key. A later action rebuilds its payload
+        // from the current form, so a token can never outlive the values it was
+        // issued for.
+        return this.runner.execute({
+            ...action,
+            needConfirmation: false,
+            payloadKeys: Object.keys(retryPayload),
+            payloadTemplate: retryPayload,
+        }, { defaultAfterSuccess, silent: true });
+    }
     /**
      * One entry per failing rule, so the footer can list them instead of
      * rendering one newline-joined blob. A single-entry array is the normal
@@ -3192,10 +3198,10 @@ class WorkCenterActionValidationHandler {
         return messages;
     }
     /**
-     * The one place a Work Center action prompts about warnings: the
-     * `process-submit/validate` pre-flight in `WorkCenterActionFormValidator`,
-     * before the action runs. Nothing on the action's own response path opens
-     * this dialog.
+     * Shared by the `actions/validate` pre-flight in
+     * `WorkCenterActionFormValidator` and by the `recover` fallback above. In the
+     * normal flow only the pre-flight raises it; a second prompt means the
+     * backend came back with warnings the pre-flight had not seen.
      *
      * Uses the client form's own warnings dialog so an approver sees the exact
      * same prompt the normal submit path raises — same layout, same wording
@@ -3243,6 +3249,8 @@ function readProcessActionValidationError(error) {
         : [];
     return {
         kind,
+        requiresAcknowledgement: details?.['requiresAcknowledgement'] === true,
+        validationWarningsToken: readNonEmptyString$1(details?.['validationWarningsToken']),
         message: readNonEmptyString$1(errors?.['message']),
         results,
     };
@@ -3289,75 +3297,108 @@ function readNonEmptyString$1(value) {
     return normalized.length ? normalized : null;
 }
 
-const PROCEED = { status: 'proceed' };
-/** The payload key carrying the edited client-form values. */
-const FORM_VALUES_PAYLOAD_KEY = 'values';
+const PROCEED = {
+    status: 'proceed',
+    validationWarningsToken: null,
+};
 /**
- * Runs `process-submit/validate` before a Work Center action that submits
- * edited client-form values (Approve, Resubmit, …).
+ * The backend action names this endpoint accepts, keyed by the runtime
+ * descriptor's `actionKey`. Reject / Return / Terminate are deliberately
+ * absent: they are not validated against the approval form and must never be
+ * pre-flighted.
+ */
+const PREFLIGHT_ACTIONS = {
+    approve: 'Approve',
+    resubmit: 'Resubmit',
+};
+const SILENT_MESSAGE_HEADERS = new HttpHeaders({ noMessage: 'true' });
+/**
+ * Runs the action-aware validation pre-flight before Approve and Resubmit.
+ *
+ * The endpoint is `POST processes/{requestId}/actions/validate`, a sibling of
+ * the action itself. It is deliberately **not** `process-submit/validate`:
+ * that one answers for a create/edit submit and carries no active request,
+ * step, action or effective approval form, so it validates the wrong scope for
+ * an approval.
  *
- * Why this exists: the process action endpoints answer `200` for non-blocking
- * rule failures, so an approver never sees the warnings that the same values
- * would raise on the normal submit path. This pre-flight reproduces the
- * client-form submit ceremony — blocking failures stop the action, warnings
- * raise the acknowledge-and-continue prompt — without submitting anything.
+ * Three outcomes, all HTTP `200`:
  *
- * It is advisory only — the action endpoint stays authoritative — but it is the
- * single place a Work Center action ever asks about warnings. Nothing is
- * negotiated afterwards: the action runs once and its answer stands.
+ * - `Blocked` — the action is never sent, and the messages go to the footer;
+ * - `Warning` — the messages are shown, and a confirmed prompt hands the
+ *   `validationWarningsToken` to the action that follows;
+ * - `Valid` — straight through, no token.
+ *
+ * The action endpoint stays authoritative and revalidates immediately before it
+ * changes workflow state, so a pre-flight that cannot be reached lets the action
+ * through rather than stranding it. See
+ * `WorkCenterActionValidationHandler.recover` for what happens when that second
+ * opinion disagrees.
  */
 class WorkCenterActionFormValidator {
-    api = inject(ClientFormApiService);
+    http = inject(HttpClient);
     actionContext = inject(RuntimeActionContextStore);
-    contextStore = inject(WorkCenterActionFormStore);
     warnings = inject(WorkCenterActionValidationHandler);
     transloco = inject(TranslocoService);
     async validate(action) {
-        const context = this.contextStore.context();
-        if (!context || !submitsFormValues(action)) {
+        const actionName = PREFLIGHT_ACTIONS[normalizeActionKey(action.actionKey)];
+        const url = resolveValidateUrl(action);
+        if (!actionName || !url) {
             return PROCEED;
         }
-        const fields = this.actionContext.resolveFormValues();
-        if (!fields.length) {
-            return PROCEED;
-        }
-        const validation = await this.runValidation(context, fields);
+        const validation = await this.runValidation(url, {
+            stepId: resolveStepId(action),
+            action: actionName,
+            // An action form with no editable fields sends `[]`, which the backend
+            // accepts — a read-only approver is still validated.
+            values: this.actionContext.resolveFormValues(),
+        });
         // A transport failure must not strand an otherwise valid action: the
         // pre-flight is advisory and the action endpoint validates again anyway.
         if (!validation) {
             return PROCEED;
         }
-        const failures = (validation.results ?? []).filter(shouldSurface);
-        const blocking = failures.filter(isBlocking);
-        if (validation.hasBlockingFailures || blocking.length) {
-            const messages = this.resolveMessages(blocking.length ? blocking : failures);
+        const failures = (validation.validation?.results ?? []).filter((result) => !result.passed);
+        if (validation.status === 'Blocked' ||
+            !validation.canProceed ||
+            validation.validation?.hasBlockingFailures) {
             return {
                 status: 'blocked',
-                error: new WorkCenterFormValidationError(messages.length
-                    ? messages
-                    : [
-                        this.transloco.translate('workCenter.actions.validationBlocked'),
-                    ]),
+                error: this.blockedError(validation, failures),
             };
         }
-        if (!failures.length) {
+        if (validation.status !== 'Warning' &&
+            !validation.requiresAcknowledgement) {
             return PROCEED;
         }
         const confirmed = await this.warnings.confirmWarnings(this.resolveMessages(failures));
-        return confirmed ? PROCEED : { status: 'cancelled' };
+        return confirmed
+            ? {
+                status: 'proceed',
+                validationWarningsToken: readNonEmptyString(validation.validationWarningsToken),
+            }
+            : { status: 'cancelled' };
     }
-    async runValidation(context, fields) {
-        const response = await firstValueFrom(this.api
-            .validate(buildValidationRequest(context, fields), true)
+    async runValidation(url, request) {
+        const response = await firstValueFrom(this.http
+            .post(url, request, { headers: SILENT_MESSAGE_HEADERS })
             .pipe(catchError(() => of(null))));
-        return response?.data ?? null;
+        return response?.code === 1 ? (response.data ?? null) : null;
+    }
+    blockedError(validation, failures) {
+        const messages = this.resolveMessages(failures);
+        if (messages.length) {
+            return new WorkCenterFormValidationError(messages);
+        }
+        return new WorkCenterFormValidationError([
+            readNonEmptyString(validation.message) ??
+                this.transloco.translate('workCenter.actions.validationBlocked'),
+        ]);
     }
     resolveMessages(results) {
         const messages = [];
         const seen = new Set();
         for (const result of results) {
-            const message = resolveLocalizedText(result.message, this.transloco.getActiveLang()) ??
-                readNonEmptyString(result.errorMessage);
+            const message = resolveLocalizedText(result.message, this.transloco.getActiveLang());
             if (!message || seen.has(message))
                 continue;
             seen.add(message);
@@ -3372,51 +3413,31 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.8", ngImpor
             type: Injectable
         }] });
 /**
- * Mirrors `buildSubmitRequest` in `ClientForm`, minus the pieces a pre-flight
- * must never send (`templateId`) or cannot know from outside the form
- * (`IsSteps`, which only applies to stepped/wizard forms).
+ * The pre-flight is the action's own sibling route, so it is derived from the
+ * descriptor's URL rather than rebuilt from a `requestId` the FE would have to
+ * source somewhere else — `.../processes/{requestId}/actions/approve` becomes
+ * `.../processes/{requestId}/actions/validate`. That also keeps both calls on
+ * whatever base the backend handed out.
  */
-function buildValidationRequest(context, fields) {
-    const request = {
-        moduleKey: context.moduleKey,
-        operationKey: context.operationKey,
-        fields,
-    };
-    if (context.moduleId != null)
-        request.moduleId = context.moduleId;
-    if (context.levelId != null)
-        request.levelId = context.levelId;
-    if (context.levelDataId != null)
-        request.levelDataId = context.levelDataId;
-    if (context.moduleDataId != null)
-        request.moduleDataId = context.moduleDataId;
-    if (context.requestSchemaId != null) {
-        request.requestSchemaId = context.requestSchemaId;
-    }
-    const recordId = context.moduleDataId ??
-        (context.moduleKey === 'LevelData' && context.operationKey !== 'Create'
-            ? context.levelDataId
-            : undefined);
-    if (recordId != null)
-        request.recordId = recordId;
-    return request;
-}
-/**
- * Only actions that carry the edited form values are worth validating —
- * Delete, Close and friends submit nothing the rules can read.
- */
-function submitsFormValues(action) {
-    return ((action.payloadKeys ?? []).includes(FORM_VALUES_PAYLOAD_KEY) ||
-        (!!action.payloadTemplate &&
-            FORM_VALUES_PAYLOAD_KEY in action.payloadTemplate));
+function resolveValidateUrl(action) {
+    const url = action.url?.trim().split(/[?#]/)[0].replace(/\/+$/, '');
+    if (!url) {
+        return null;
+    }
+    const lastSlash = url.lastIndexOf('/');
+    return lastSlash > 0 ? `${url.slice(0, lastSlash)}/validate` : null;
 }
-// These two mirror `process-validation.util` in `@masterteam/forms/client-form`,
-// which the package does not export. Keep them in step with it.
-function shouldSurface(result) {
-    return !result.passed || result.isEvaluationError === true;
+/** The same resolution the action payload uses for its own `stepId`. */
+function resolveStepId(action) {
+    const templateStepId = action.payloadTemplate?.['stepId'];
+    if (typeof templateStepId === 'number' ||
+        typeof templateStepId === 'string') {
+        return templateStepId;
+    }
+    return action.stepIds?.[0] ?? null;
 }
-function isBlocking(result) {
-    return (result.isEvaluationError === true || (!result.passed && result.isBlocking));
+function normalizeActionKey(value) {
+    return typeof value === 'string' ? value.trim().toLowerCase() : '';
 }
 function readNonEmptyString(value) {
     if (typeof value !== 'string')
@@ -3426,18 +3447,20 @@ function readNonEmptyString(value) {
 }
 
 /**
- * Runs a Work Center footer action as **one** HTTP request.
+ * Runs a Work Center footer action, normally as a single HTTP request.
  *
- * Everything negotiable happens before that request: the
- * `process-submit/validate` pre-flight blocks the action or takes the
- * acknowledgement, then the reason/note dialog collects its fields. Whatever
- * the action endpoint answers is final — the footer refreshes on success or
- * lists the failure.
+ * Everything negotiable happens before it: the `actions/validate` pre-flight
+ * blocks the action or takes the warning acknowledgement, then the reason/note
+ * dialog collects its fields, and the acknowledgement receipt rides along on
+ * the request itself. A second request happens only when the backend's own
+ * revalidation disagrees with the pre-flight — see
+ * `WorkCenterActionValidationHandler.recover`.
  */
 class WorkCenterRuntimeActionExecutor {
     runner = inject(RuntimeActionRunner);
     actionContext = inject(RuntimeActionContextStore);
     modal = inject(ModalService);
+    validation = inject(WorkCenterActionValidationHandler);
     formValidation = inject(WorkCenterActionFormValidator);
     confirmDialogClass = inject(RUNTIME_ACTION_CONFIRM_DIALOG, {
         optional: true,
@@ -3462,20 +3485,33 @@ class WorkCenterRuntimeActionExecutor {
                 error: preflight.error,
             };
         }
+        // The receipt for the warnings the user just acknowledged. It goes out with
+        // the action itself, so an acknowledged Approve is a single request.
+        const warningsToken = preflight.validationWarningsToken;
         if (action.needConfirmation &&
             hasActionFormFields(action) &&
             this.confirmDialogClass) {
-            return this.executeFormAction(action, defaultAfterSuccess);
+            return this.executeFormAction(action, defaultAfterSuccess, warningsToken);
         }
-        return this.runner.execute(action, {
+        let submittedPayload;
+        let result = await this.runner.execute(action, {
             defaultAfterSuccess,
             silent: true,
             externalPayloadResolvers: {
                 values: () => this.actionContext.resolveFormValues(),
             },
+            transformPayload: (payload) => {
+                submittedPayload = withWarningsToken(payload, warningsToken);
+                return submittedPayload;
+            },
         });
+        if (result.status === 'error') {
+            result =
+                (await this.validation.recover(action, result.error, submittedPayload, defaultAfterSuccess)) ?? result;
+        }
+        return result;
     }
-    executeFormAction(action, defaultAfterSuccess) {
+    executeFormAction(action, defaultAfterSuccess, warningsToken) {
         return new Promise((resolve) => {
             let pendingRun = null;
             let finalResult = null;
@@ -3486,19 +3522,27 @@ class WorkCenterRuntimeActionExecutor {
                 inputValues: {
                     action,
                     onSubmit: async (formValue) => {
-                        const executablePayload = buildActionPayload(action, formValue, {
+                        const submittedPayload = withWarningsToken(buildActionPayload(action, formValue, {
                             values: () => this.actionContext.resolveFormValues(),
-                        }) ?? {};
+                        }), warningsToken);
+                        const executablePayload = submittedPayload ?? {};
                         const executableAction = {
                             ...action,
                             needConfirmation: false,
                             payloadKeys: Object.keys(executablePayload),
                             payloadTemplate: executablePayload,
                         };
-                        pendingRun = this.runner.execute(executableAction, {
-                            defaultAfterSuccess,
-                            silent: true,
-                        });
+                        pendingRun = (async () => {
+                            let result = await this.runner.execute(executableAction, {
+                                defaultAfterSuccess,
+                                silent: true,
+                            });
+                            if (result.status === 'error') {
+                                result =
+                                    (await this.validation.recover(action, result.error, submittedPayload, defaultAfterSuccess)) ?? result;
+                            }
+                            return result;
+                        })();
                         finalResult = await pendingRun;
                         // Every backend outcome leaves the action dialog. The footer then
                         // refreshes on success or displays the actionable validation error.
@@ -3539,6 +3583,17 @@ class WorkCenterRuntimeActionExecutor {
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: WorkCenterRuntimeActionExecutor, decorators: [{
             type: Injectable
         }] });
+/**
+ * Attaches the pre-flight's acknowledgement receipt to the payload the action
+ * is about to send. Without a receipt — a `Valid` pre-flight, or one that never
+ * ran — the payload goes out exactly as built.
+ */
+function withWarningsToken(payload, warningsToken) {
+    if (!warningsToken || !payload) {
+        return payload;
+    }
+    return { ...payload, validationWarningsToken: warningsToken };
+}
 
 const DEFAULT_GENERAL_TASK_MODAL_STYLE_CLASS = '!w-[70vw] !h-[90vh]';
 class WorkCenterItemModalFooterActions {