@salesforce/lds-drafts 1.173.0 → 1.174.0

package/dist/ldsDrafts.js

@@ -234,13 +234,40 @@ function uuidv4() {
     return uuid.join('');
 }
 
-const IdempotencyKey = 'Idempotency-Key';
+const HTTP_HEADER_RETRY_AFTER = 'Retry-After';
+const HTTP_HEADER_IDEMPOTENCY_KEY = 'Idempotency-Key';
+const ERROR_CODE_IDEMPOTENCY_KEY_USED_DIFFERENT_USER = 'IDEMPOTENCY_KEY_USED_DIFFERENT_USER';
+const ERROR_CODE_IDEMPOTENCY_CONCURRENT_REQUEST = 'IDEMPOTENCY_CONCURRENT_REQUEST';
+/**
+ * Get the retry after in milliseconds from the response headers, undefined if not specified.
+ * The header could have two different format.
+ * Retry-After: <http-date>, like Wed, 21 Oct 2015 07:28:00 GMT
+ * Retry-After: <delay-seconds>, like 1.5s
+ * @param headers http headers
+ * @returns the time to delat in millisconds.
+ */
+function getRetryAfterInMs(headers) {
+    const retryAfterHeader = headers && headers[HTTP_HEADER_RETRY_AFTER];
+    if (retryAfterHeader === undefined) {
+        return undefined;
+    }
+    const delayInSecond = parseFloat(retryAfterHeader);
+    if (retryAfterHeader === delayInSecond.toString()) {
+        return Math.round(delayInSecond * 1000);
+    }
+    const delayUntilDateTime = Date.parse(retryAfterHeader);
+    if (isNaN(delayUntilDateTime)) {
+        return undefined;
+    }
+    return delayUntilDateTime - Date.now();
+}
+
 function buildLuvioOverrideForDraftAdapters(luvio, handler, extractTargetIdFromCacheKey, options = {}) {
     // override this to create and enqueue a new draft action, and return synthetic response
     const dispatchResourceRequest = async function (resourceRequest, _context) {
         const resourceRequestCopy = clone(resourceRequest);
         resourceRequestCopy.headers = resourceRequestCopy.headers || {};
-        resourceRequestCopy.headers[IdempotencyKey] = uuidv4();
+        resourceRequestCopy.headers[HTTP_HEADER_IDEMPOTENCY_KEY] = uuidv4();
         const { data } = await handler.enqueue(resourceRequestCopy).catch((err) => {
             throw transformErrorToDraftSynthesisError(err);
         });
@@ -603,11 +630,19 @@ class DurableDraftQueue {
             },
         });
     }
-    async actionFailed(action, retry) {
+    async actionFailed(action, retry, retryDelayInMs, actionDataChanged) {
+        if (actionDataChanged === true) {
+            await this.draftStore.writeAction({
+                ...action,
+                status: DraftActionStatus.Pending,
+            });
+        }
         this.uploadingActionId = undefined;
         if (retry && this.state !== DraftQueueState.Stopped) {
             this.state = DraftQueueState.Waiting;
-            this.scheduleRetry();
+            return retryDelayInMs !== undefined
+                ? this.scheduleRetryWithSpecifiedDelay(retryDelayInMs)
+                : this.scheduleRetry();
         }
         else if (isDraftError(action)) {
             return this.handleServerError(action, action.error);
@@ -753,14 +788,17 @@ class DurableDraftQueue {
         });
         return action;
     }
-    scheduleRetry() {
-        const newInterval = this.retryIntervalMilliseconds * 2;
-        this.retryIntervalMilliseconds = Math.min(Math.max(newInterval, this.minimumRetryInterval), this.maximumRetryInterval);
+    scheduleRetryWithSpecifiedDelay(retryDelayInMs) {
         this.timeoutHandler = setTimeout(() => {
             if (this.state !== DraftQueueState.Stopped) {
                 this.processNextAction();
             }
-        }, this.retryIntervalMilliseconds);
+        }, retryDelayInMs);
+    }
+    scheduleRetry() {
+        const newInterval = this.retryIntervalMilliseconds * 2;
+        this.retryIntervalMilliseconds = Math.min(Math.max(newInterval, this.minimumRetryInterval), this.maximumRetryInterval);
+        this.scheduleRetryWithSpecifiedDelay(this.retryIntervalMilliseconds);
     }
     async getActionsForReplaceOrMerge(targetActionId, sourceActionId) {
         const actions = await this.getQueueActions();
@@ -1076,14 +1114,47 @@ class AbstractResourceRequestActionHandler {
                 });
                 return ProcessActionResult.ACTION_SUCCEEDED;
             }
-            await actionErrored({
-                ...action,
-                error: response,
-                status: DraftActionStatus.Error,
-            }, false);
+            let shouldRetry = false;
+            let retryDelayInMs = undefined;
+            let actionDataChanged = false;
+            let updatedAction = action;
+            if (request && request.headers && request.headers[HTTP_HEADER_IDEMPOTENCY_KEY]) {
+                const status = response.status;
+                switch (status) {
+                    case 408 /* IdempotentWriteSpecificHttpStatusCode.RequestTimeout */:
+                    case 503 /* IdempotentWriteSpecificHttpStatusCode.ServiceUnavailable */:
+                        retryDelayInMs = getRetryAfterInMs(response.headers);
+                        shouldRetry = true;
+                        break;
+                    case HttpStatusCode.ServerError:
+                        shouldRetry = true;
+                        break;
+                    case 409 /* IdempotentWriteSpecificHttpStatusCode.Conflict */: {
+                        const errorCode = JSON.parse(response.body)[0].errorCode;
+                        if (errorCode === ERROR_CODE_IDEMPOTENCY_KEY_USED_DIFFERENT_USER) {
+                            updatedAction.data.headers = updatedAction.data.headers || {};
+                            updatedAction.data.headers[HTTP_HEADER_IDEMPOTENCY_KEY] = uuidv4();
+                            retryDelayInMs = 0;
+                            actionDataChanged = true;
+                        }
+                        else if (errorCode === ERROR_CODE_IDEMPOTENCY_CONCURRENT_REQUEST) {
+                            retryDelayInMs = getRetryAfterInMs(response.headers);
+                        }
+                        shouldRetry = true;
+                        break;
+                    }
+                }
+            }
+            await actionErrored(shouldRetry
+                ? updatedAction
+                : {
+                    ...updatedAction,
+                    error: response,
+                    status: DraftActionStatus.Error,
+                }, shouldRetry, retryDelayInMs, actionDataChanged);
             return ProcessActionResult.ACTION_ERRORED;
         }
-        catch (_a) {
+        catch (e) {
             await actionErrored(action, true);
             return ProcessActionResult.NETWORK_ERROR;
         }

package/dist/types/DraftAwareAdapter.d.ts

@@ -1,7 +1,6 @@
 import type { DispatchResourceRequestContext, Luvio, Snapshot } from '@luvio/engine';
 import type { AbstractResourceRequestActionHandler } from './actionHandlers/AbstractResourceRequestActionHandler';
 export type AdapterBuildNetworkSnapshot<Config, Response> = (luvio: Luvio, config: Config, dispatchResourceRequestContext?: DispatchResourceRequestContext) => Promise<Snapshot<Response>>;
-export declare const IdempotencyKey = "Idempotency-Key";
 export declare function buildLuvioOverrideForDraftAdapters<ResponseType = unknown, DraftMetadata = unknown>(luvio: Luvio, handler: AbstractResourceRequestActionHandler<ResponseType, DraftMetadata>, extractTargetIdFromCacheKey: (cacheKey: string) => string | undefined, options?: {
     forDeleteAdapter?: boolean;
 }): Luvio;

package/dist/types/DurableDraftQueue.d.ts

@@ -34,7 +34,7 @@ export declare class DurableDraftQueue implements DraftQueue {
     enqueue<Data, Response>(handlerId: string, data: unknown): Promise<EnqueueResult<Data, Response>>;
     registerOnChangedListener(listener: DraftQueueChangeListener): () => Promise<void>;
     actionCompleted(action: CompletedDraftAction<unknown, unknown>): Promise<void>;
-    actionFailed(action: DraftAction<unknown, unknown>, retry: boolean): Promise<void>;
+    actionFailed(action: DraftAction<unknown, unknown>, retry: boolean, retryDelayInMs?: number, actionDataChanged?: boolean): Promise<void>;
     handle(action: DraftAction<unknown, unknown>): Promise<ProcessActionResult>;
     processNextAction(): Promise<ProcessActionResult>;
     private handleServerError;
@@ -48,6 +48,7 @@ export declare class DurableDraftQueue implements DraftQueue {
     replaceAction<Data, Response>(targetActionId: string, sourceActionId: string): Promise<DraftAction<Data, Response>>;
     mergeActions<Data, Response>(targetActionId: string, sourceActionId: string): Promise<DraftAction<Data, Response>>;
     setMetadata(actionId: string, metadata: DraftActionMetadata): Promise<DraftAction<unknown, unknown>>;
+    private scheduleRetryWithSpecifiedDelay;
     private scheduleRetry;
     private getActionsForReplaceOrMerge;
     private assertReplaceOrMergePrerequisites;

package/dist/types/actionHandlers/AbstractResourceRequestActionHandler.d.ts

@@ -16,7 +16,7 @@ export declare abstract class AbstractResourceRequestActionHandler<ResponseType,
     };
     constructor(draftQueue: DraftQueue, networkAdapter: NetworkAdapter, getLuvio: () => Luvio);
     enqueue(data: ResourceRequest): Promise<EnqueueResult<ResourceRequest, ResponseType>>;
-    handleAction(action: DraftAction<ResourceRequest, ResponseType>, actionCompleted: (action: CompletedDraftAction<ResourceRequest, ResponseType>) => Promise<void>, actionErrored: (action: DraftAction<ResourceRequest, ResponseType>, retry: boolean) => Promise<void>): Promise<ProcessActionResult>;
+    handleAction(action: DraftAction<ResourceRequest, ResponseType>, actionCompleted: (action: CompletedDraftAction<ResourceRequest, ResponseType>) => Promise<void>, actionErrored: (action: DraftAction<ResourceRequest, ResponseType>, retry: boolean, retryDelayInMs?: number, actionDataChanged?: boolean) => Promise<void>): Promise<ProcessActionResult>;
     buildPendingAction(request: ResourceRequest, queue: DraftAction<unknown, unknown>[]): Promise<PendingDraftAction<ResourceRequest>>;
     handleActionEnqueued(action: PendingDraftAction<ResourceRequest>): Promise<void>;
     handleActionRemoved(action: DraftAction<ResourceRequest, ResponseType>): Promise<void>;

package/dist/types/actionHandlers/ActionHandler.d.ts

@@ -57,7 +57,7 @@ export interface ActionHandler<Data, DraftMetadata, Type> {
      * @param actionCompleted callback function when the action completes successfully
      * @param actionErrored callback function invoked when the action errors
      */
-    handleAction(action: DraftAction<Data, Type>, actionCompleted: (action: CompletedDraftAction<Data, Type>) => Promise<void>, actionErrored: (action: DraftAction<Data, Type>, retry: boolean) => Promise<void>): Promise<ProcessActionResult>;
+    handleAction(action: DraftAction<Data, Type>, actionCompleted: (action: CompletedDraftAction<Data, Type>) => Promise<void>, actionErrored: (action: DraftAction<Data, Type>, retry: boolean, retryDelayInMs?: number, actionDataChanged?: boolean) => Promise<void>): Promise<ProcessActionResult>;
     /**
      * Invoked by the draft queue after an action for this handler is removed from the queue
      * @param action: the removed action

package/dist/types/actionHandlers/IdempotentWrite.d.ts

@@ -0,0 +1,28 @@
+import type { HttpStatusCode, Headers } from '@luvio/engine';
+export interface UIApiError {
+    errorCode: string;
+    message: string | null;
+}
+export declare const enum IdempotentWriteSpecificHttpStatusCode {
+    RequestTimeout = 408,
+    Conflict = 409,
+    BadGateway = 502,
+    ServiceUnavailable = 503
+}
+/**
+ * The http status code which could be returned from idempotent write.
+ */
+export type IdempotentWriteHttpStatusCode = IdempotentWriteSpecificHttpStatusCode | HttpStatusCode;
+export declare const HTTP_HEADER_RETRY_AFTER = "Retry-After";
+export declare const HTTP_HEADER_IDEMPOTENCY_KEY = "Idempotency-Key";
+export declare const ERROR_CODE_IDEMPOTENCY_KEY_USED_DIFFERENT_USER = "IDEMPOTENCY_KEY_USED_DIFFERENT_USER";
+export declare const ERROR_CODE_IDEMPOTENCY_CONCURRENT_REQUEST = "IDEMPOTENCY_CONCURRENT_REQUEST";
+/**
+ * Get the retry after in milliseconds from the response headers, undefined if not specified.
+ * The header could have two different format.
+ * Retry-After: <http-date>, like Wed, 21 Oct 2015 07:28:00 GMT
+ * Retry-After: <delay-seconds>, like 1.5s
+ * @param headers http headers
+ * @returns the time to delat in millisconds.
+ */
+export declare function getRetryAfterInMs(headers?: Headers): number | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-drafts",
-    "version": "1.173.0",
+    "version": "1.174.0",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "LDS Drafts",
     "main": "dist/ldsDrafts.js",