@wildo-ai/saas-frontend-lib 1.1.9 → 1.1.11

package/dist/esm/core/resources/rmm/ResourceMutationManager.js

@@ -11,12 +11,13 @@
  *                SAVING → CONFLICT → IDLE (acknowledge)
  *                ANY → DELETED (terminal)
  */
-import { DataMode, extractCrdtFieldNames, lwwFieldWinner, nextMonotonicTimestamp, CrdtResolutionWinner, sanitizeFieldMeta, CoreResourceOperation, ErrorCustomMessageReference, ResourcesConfig_OperationPathUtils, describeCaughtError } from '@wildo-ai/saas-models';
+import { DataMode, extractResourceCrdtFieldNames, lwwFieldWinner, nextMonotonicTimestamp, CrdtResolutionWinner, sanitizeFieldMeta, CoreResourceOperation, ErrorCustomMessageReference, ResourcesConfig_OperationPathUtils, describeCaughtError } from '@wildo-ai/saas-models';
 import { frontendEventBus } from '../../../core/events/event-bus.frontend.service.js';
 import { FrontendEvents } from '../../../core/events/events.frontend.schemas.js';
 import { RMMState, RMMEventType, MutationType, MutationSourceType, MutationErrorType, OperationResultStatus, ConflictStrategy, ConflictReason, MutationPriority, MutationCancelledError, ResourceDeletedError, BackpressureRejectedError, } from './types.js';
 import { RMM_HARD_TIMEOUT_MS, RMM_MAX_QUEUE_DEPTH, RMM_SERVER_RETRY_DELAY_MS, RMM_SOFT_TIMEOUT_MS, RMM_TRANSIENT_RETRY_DELAYS, } from './rmm-constants.js';
 import { rmmFieldPathsOverlap, rmmNormalizeFieldPath, rmmReadPathValue } from './field-path.utils.js';
+import { carryStoredDiscriminators, resolveDiscriminatorFieldNames } from '../../../core/resources/resource-discriminators.frontend.utils.js';
 import { LoggerFrontendService } from '../../../core/monitoring/logger.frontend.service.js';
 import { describeErrorGuidance, describeResourceErrorForNotification } from '../../../components/form/validation-errors/resource-error-notification-context.utils.js';
 // =============================================================================
@@ -89,6 +90,12 @@ function buildWireRequestData(savingFields, confirmedData) {
     const dottedKeys = Object.keys(savingFields).filter((key) => rmmNormalizeFieldPath(key).includes('.'));
     if (dottedKeys.length === 0)
         return savingFields;
+    // With no confirmed state yet, there are no stored siblings to carry, and the parent would go out holding only the
+    // edited child: the server would erase the rest. Refused until the state is known (the send is retried as transient).
+    // A parent the confirmed record does not hold is different: it has no siblings, so nesting alone is right.
+    if (confirmedData === null) {
+        throw new Error(`Cannot write ${dottedKeys.join(', ')} before the record's stored state is known: the stored siblings would be erased.`);
+    }
     const wire = {};
     for (const [key, value] of Object.entries(savingFields)) {
         if (!dottedKeys.includes(key))
@@ -108,6 +115,18 @@ function buildWireRequestData(savingFields, confirmedData) {
     }
     return wire;
 }
+/**
+ * The mutation types that write PART of a record: some of its fields, as the form held them when the write was queued
+ * (a section's Save, an autosave, an inline edit). Two things apply to them and to nothing else:
+ *
+ * - The record's stored discriminator is added to their body (`carryStoredDiscriminators`). A whole-form write (submit,
+ *   draft, publish) sends what the form holds, discriminator included when its request declares it; adding one it
+ *   does not declare would be refused by a strict request DTO of a custom update.
+ * - Their result reports the values sent (`MutationResult.savedValues`), which a form compares with what each field
+ *   holds now. A whole-form write sends the values AFTER the schema parsed them (trimmed, coerced, defaulted), which
+ *   never match the raw values the fields hold, so the comparison would leave every such field unsaved.
+ */
+const PARTIAL_WRITE_MUTATION_TYPES = new Set([MutationType.SECTION, MutationType.AUTOSAVE, MutationType.INLINE]);
 function deepSetByPath(obj, path, value) {
     const segments = rmmNormalizeFieldPath(path).split('.').filter(Boolean);
     let current = obj;
@@ -214,6 +233,8 @@ export class ResourceMutationManager {
     _producedVersions = new Set();
     // --- CRDT Metadata ---
     _crdtFieldNames;
+    /** The variant discriminator fields of a polymorphic resource, added to every body this manager builds when it sends. */
+    _discriminatorFieldNames;
     _fieldMeta = null;
     _pendingFieldTimestamps = new Map();
     _lastIssuedLocalTimestamp = 0;
@@ -230,7 +251,8 @@ export class ResourceMutationManager {
             softTimeoutMs: bp?.softTimeoutMs ?? DEFAULT_BACKPRESSURE.softTimeoutMs,
             hardTimeoutMs: bp?.hardTimeoutMs ?? DEFAULT_BACKPRESSURE.hardTimeoutMs,
         };
-        this._crdtFieldNames = extractCrdtFieldNames(config.resourceSchema);
+        this._crdtFieldNames = extractResourceCrdtFieldNames({ mainSchema: config.resourceSchema, inheritenceSchemaDefinition: config.resourceInheritance });
+        this._discriminatorFieldNames = resolveDiscriminatorFieldNames(config.resourceSchema);
         this.subscribe = this.subscribe.bind(this);
         this.getSnapshot = this.getSnapshot.bind(this);
         logDebug('constructor', {
@@ -299,7 +321,8 @@ export class ResourceMutationManager {
         const didUpdateTransportAdapter = patch.transportAdapter !== undefined && patch.transportAdapter !== this._config.transportAdapter;
         const didUpdateConflictPolicy = patch.conflictPolicy !== undefined
             && patch.conflictPolicy.strategy !== this._config.conflictPolicy.strategy;
-        const didUpdateResourceSchema = patch.resourceSchema !== undefined && patch.resourceSchema !== this._config.resourceSchema;
+        const didUpdateResourceSchema = (patch.resourceSchema !== undefined && patch.resourceSchema !== this._config.resourceSchema)
+            || (patch.resourceInheritance !== undefined && patch.resourceInheritance !== this._config.resourceInheritance);
         this._config = {
             ...this._config,
             ...(patch.transportAdapter !== undefined ? { transportAdapter: patch.transportAdapter } : {}),
@@ -315,9 +338,11 @@ export class ResourceMutationManager {
             ...(hasReadOperationPathKeyPatch ? { readOperationPathKey: patch.readOperationPathKey } : {}),
             ...(patch.conflictPolicy !== undefined ? { conflictPolicy: patch.conflictPolicy } : {}),
             ...(patch.resourceSchema !== undefined ? { resourceSchema: patch.resourceSchema } : {}),
+            ...(patch.resourceInheritance !== undefined ? { resourceInheritance: patch.resourceInheritance } : {}),
         };
         if (didUpdateResourceSchema) {
-            this._crdtFieldNames = extractCrdtFieldNames(patch.resourceSchema);
+            this._crdtFieldNames = extractResourceCrdtFieldNames({ mainSchema: this._config.resourceSchema, inheritenceSchemaDefinition: this._config.resourceInheritance });
+            this._discriminatorFieldNames = resolveDiscriminatorFieldNames(this._config.resourceSchema);
         }
         logDebug('syncRuntimeRoutingConfig', {
             resourceType: this.resourceType,
@@ -785,21 +810,29 @@ export class ResourceMutationManager {
                     this._queue.length > 0 || this._pendingFields.size > 0 ? RMMState.QUEUED : RMMState.IDLE;
                 this._lastError = null;
                 this._clearTimers();
-                if (event.result.data) {
-                    this._mergeResponseDataIntoConfirmed(event.result.data);
-                }
-                this._applyConfirmedClears(event.clearedFields, event.result.data);
-                if (event.result.newVersion !== undefined) {
-                    this._version = event.result.newVersion;
+                // #2288: a write held for approval changed nothing. The confirmed row, its clears and its version stay as they
+                // were, and the result names no saved field, so no surface marks the person's values as stored.
+                const heldForApproval = event.result.heldForApproval;
+                if (!heldForApproval) {
+                    if (event.result.data) {
+                        this._mergeResponseDataIntoConfirmed(event.result.data);
+                    }
+                    this._applyConfirmedClears(event.clearedFields, event.result.data);
+                    if (event.result.newVersion !== undefined) {
+                        this._version = event.result.newVersion;
+                    }
                 }
                 this._lastEvent = {
                     type: RMMEventType.MUTATION_RESULT,
-                    result: {
-                        success: true,
-                        savedFields: event.savedFields,
-                        newVersion: event.result.newVersion,
-                        responseData: event.result.data,
-                    },
+                    result: heldForApproval
+                        ? { success: true, savedFields: [], heldForApproval }
+                        : {
+                            success: true,
+                            savedFields: event.savedFields,
+                            savedValues: event.savedValues,
+                            newVersion: event.result.newVersion,
+                            responseData: event.result.data,
+                        },
                     source: event.source,
                     id: ++this._eventCounter,
                 };
@@ -815,6 +848,7 @@ export class ResourceMutationManager {
                         message: event.result.error.message,
                         conflictDetails: event.result.error.conflictDetails,
                         cause: event.result.error.cause,
+                        ...(event.result.error.resendable === undefined ? {} : { resendable: event.result.error.resendable }),
                     }
                     : { type: MutationErrorType.SERVER, message: 'Unknown error' };
                 this._lastError = mutationError;
@@ -862,8 +896,10 @@ export class ResourceMutationManager {
                     }
                     break;
                 }
-                // --- Validation / Not Found (no retry, with lastEvent) ---
-                if (errorType === MutationErrorType.VALIDATION || errorType === MutationErrorType.NOT_FOUND) {
+                // --- Validation / Not Found / Refused (no retry, with lastEvent) ---
+                // Only a VALIDATION failure keeps the edit pending: the person can correct the field. A refused field cannot
+                // be corrected, and a pending one would ride along with every later save of the record and fail it too.
+                if (errorType === MutationErrorType.VALIDATION || errorType === MutationErrorType.NOT_FOUND || errorType === MutationErrorType.REFUSED) {
                     this._clearTimers();
                     if (errorType === MutationErrorType.VALIDATION && this._activeMutation) {
                         for (const field of event.savedFields) {
@@ -889,11 +925,15 @@ export class ResourceMutationManager {
                 }
                 // --- Transient / Server (may retry) ---
                 const retryCount = this._activeMutation?.retryCount ?? 0;
-                const maxRetries = errorType === MutationErrorType.TRANSIENT
-                    ? this._retryDelays.length
-                    : errorType === MutationErrorType.SERVER
-                        ? 1
-                        : 0;
+                // A request that may already have been applied is never resent automatically (#3004, RFC 9110 §9.2.2): it settles
+                // now, as an exhausted retry does, and the person decides.
+                const maxRetries = mutationError.resendable === false
+                    ? 0
+                    : errorType === MutationErrorType.TRANSIENT
+                        ? this._retryDelays.length
+                        : errorType === MutationErrorType.SERVER
+                            ? 1
+                            : 0;
                 if (retryCount < maxRetries) {
                     const delay = errorType === MutationErrorType.TRANSIENT
                         ? this._retryDelays[retryCount]
@@ -1216,26 +1256,41 @@ export class ResourceMutationManager {
             }
         }
         const transportOverride = thisMutation.entry.transportOverride;
-        const descriptor = {
+        const buildDescriptor = () => ({
             operationPathKey: transportOverride?.operationPathKey ?? this._config.operationPathKey ?? this._config.resourceType,
             contextualParameters: transportOverride?.contextualParameters ?? this._config.contextualParameters,
             parentResourcesRequirements: transportOverride?.parentResourcesRequirements ?? this._config.parentResourcesRequirements,
             // The queue speaks field PATHS; the server speaks the resource's own shape. See `buildWireRequestData`.
-            requestData: transportOverride?.requestData ?? buildWireRequestData(mutation.savingFields, this._confirmedData),
+            // A polymorphic resource's partial UPDATE also needs the record's variant, taken from the state confirmed NOW:
+            // captured when the write was QUEUED, it could undo a variant change a save ahead of it stored, and as a queued
+            // field it was reported saved, so the write-back reset an unsaved variant change in the form.
+            requestData: transportOverride?.requestData ?? (PARTIAL_WRITE_MUTATION_TYPES.has(mutation.entry.type)
+                ? carryStoredDiscriminators(buildWireRequestData(mutation.savingFields, this._confirmedData), this._discriminatorFieldNames, this._confirmedData)
+                : buildWireRequestData(mutation.savingFields, this._confirmedData)),
             expectedVersion: this._version,
             signal: mutation.abortController.signal,
             fieldTimestamps: Object.keys(fieldTimestamps).length > 0
                 ? fieldTimestamps
                 : undefined,
-        };
-        this._config.transportAdapter.execute(descriptor).then(async (rawResult) => {
+        });
+        // A body that cannot be built yet (`buildWireRequestData`) fails like a transport that could not be reached: the
+        // send is retried, and only then reported.
+        let execution;
+        try {
+            execution = this._config.transportAdapter.execute(buildDescriptor());
+        }
+        catch (error) {
+            execution = Promise.reject(error);
+        }
+        execution.then(async (rawResult) => {
             if (this._activeMutation !== thisMutation) {
                 logDebug('_executeTransport: stale callback — ignored', { mutationId: thisMutation.entry.id });
                 return;
             }
             const savedFields = Object.keys(thisMutation.savingFields);
             const source = thisMutation.entry.source;
-            const result = rawResult.status === OperationResultStatus.SUCCESS && transportOverride?.readBackOnSuccess
+            // A held write changed no row: there is nothing to read back, and the read-back would drop the held answer.
+            const result = rawResult.status === OperationResultStatus.SUCCESS && !rawResult.heldForApproval && transportOverride?.readBackOnSuccess
                 ? await this._readBackConfirmedState(rawResult)
                 : rawResult;
             if (result.status === OperationResultStatus.SUCCESS) {
@@ -1258,7 +1313,8 @@ export class ResourceMutationManager {
                 const clearedFields = Object.entries(thisMutation.savingFields)
                     .filter(([, fieldValue]) => fieldValue === null)
                     .map(([fieldName]) => fieldName);
-                this._transition({ type: TransitionEventType.SAVE_SUCCESS, result, savedFields, clearedFields, source });
+                const savedValues = PARTIAL_WRITE_MUTATION_TYPES.has(thisMutation.entry.type) ? thisMutation.savingFields : undefined;
+                this._transition({ type: TransitionEventType.SAVE_SUCCESS, result, savedFields, savedValues, clearedFields, source });
                 this._activeMutation = null;
                 // Remember the version THIS tab's mutation just minted, so its own
                 // WebSocket echo is recognised (and skipped) while another tab's
@@ -1266,12 +1322,15 @@ export class ResourceMutationManager {
                 this._recordProducedVersion(result.newVersion);
                 this._processDeferredSelfEvents(result.newVersion);
                 this._invalidateSnapshot();
-                thisMutation.entry.resolve({
-                    success: true,
-                    savedFields,
-                    newVersion: result.newVersion,
-                    responseData: result.data,
-                });
+                thisMutation.entry.resolve(result.heldForApproval
+                    ? { success: true, savedFields: [], heldForApproval: result.heldForApproval }
+                    : {
+                        success: true,
+                        savedFields,
+                        savedValues,
+                        newVersion: result.newVersion,
+                        responseData: result.data,
+                    });
                 this._processQueue();
                 this._notifyDrained();
             }