@salesforce/lds-drafts 1.303.0 → 1.305.0

package/dist/ldsDrafts.js

@@ -762,12 +762,60 @@ class DurableDraftQueue {
             await this.startQueue();
         }
     }
+    async updateDraftAction(action) {
+        // stop queue manually
+        this.stopQueueManually();
+        const actionStatus = await this.statusOfAction(action.id);
+        if (actionStatus === DraftActionStatus.Uploading) {
+            return Promise.reject('cannot update an uploading action');
+        }
+        // save the action into the draft store
+        await this.draftStore.writeAction(action);
+        // make the handler replay these drafts on the record
+        const handler = this.getHandler(action.handler);
+        const queue = await this.getQueueActions();
+        await handler.handleActionEnqueued(action, queue);
+        // start queue safely
+        return this.startQueueSafe();
+    }
+    async statusOfAction(actionId) {
+        const queue = await this.getQueueActions();
+        const actions = queue.filter((action) => action.id === actionId);
+        if (actions.length === 0) {
+            return Promise.reject('cannot update non-existent action');
+        }
+        const action = actions[0];
+        return action.status;
+    }
     replaceAction(targetActionId, sourceActionId) {
         return this.replaceOrMergeActions(targetActionId, sourceActionId, false);
     }
     mergeActions(targetActionId, sourceActionId) {
         return this.replaceOrMergeActions(targetActionId, sourceActionId, true);
     }
+    async retryAction(actionId) {
+        this.stopQueueManually();
+        const actions = await this.getQueueActions();
+        const target = actions[0];
+        if (!target || target.id !== actionId) {
+            throw Error(`Action ${actionId} not found at the head of the draft queue`);
+        }
+        if (!isDraftError(target)) {
+            throw Error(`Action ${actionId} is not in Error state`);
+        }
+        let pendingAction = {
+            ...target,
+            status: DraftActionStatus.Pending,
+            error: undefined,
+        };
+        await this.draftStore.writeAction(pendingAction);
+        await this.notifyChangedListeners({
+            type: DraftQueueEventType.ActionUpdated,
+            action: pendingAction,
+        });
+        await this.startQueueSafe();
+        return pendingAction;
+    }
     async setMetadata(actionId, metadata) {
         const keys$1 = keys(metadata);
         const compatibleKeys = keys$1.filter((key) => {
@@ -1765,6 +1813,60 @@ class DraftManager {
             };
         });
     }
+    async mergePerformQuickAction(actionId, fields) {
+        if (!this.isValidFieldMap(fields)) {
+            return Promise.reject('fields is not valid');
+        }
+        const queue = await this.draftQueue.getQueueActions();
+        const actions = queue.filter((action) => action.id === actionId);
+        if (actions.length === 0) {
+            return Promise.reject('cannot edit non-existent action');
+        }
+        const action = actions[0];
+        if (!this.isPerformQuickActionDraft(action, 'post')) {
+            return Promise.reject('cannot edit incompatible action type or uploading actions');
+        }
+        action.data.body.fields = { ...action.data.body.fields, ...fields };
+        await this.draftQueue.updateDraftAction(action);
+        return this.buildDraftQueueItem(action);
+    }
+    isValidFieldMap(fields) {
+        const keys$1 = keys(fields);
+        const validTypes = ['string', 'number', 'null', 'boolean'];
+        for (let i = 0; i < keys$1.length; i++) {
+            const key = keys$1[i];
+            const value = fields[key];
+            if (!validTypes.includes(typeof value)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    isPerformQuickActionDraft(action, method) {
+        const data = action.data;
+        const isPerformQuickAction = data.basePath.startsWith('/ui-api/actions/perform-quick-action/');
+        const methodMatches = data.method === method;
+        const notUploading = action.status !== DraftActionStatus.Uploading;
+        return isPerformQuickAction && methodMatches && notUploading;
+    }
+    async mergePerformUpdateRecordQuickAction(actionId, fields) {
+        if (!this.isValidFieldMap(fields)) {
+            return Promise.reject('fields is not valid');
+        }
+        const queue = await this.draftQueue.getQueueActions();
+        const actions = queue.filter((action) => action.id === actionId);
+        if (actions.length === 0) {
+            return Promise.reject('cannot edit non-existent action');
+        }
+        const action = actions[0];
+        if (!this.isPerformQuickActionDraft(action, 'patch')) {
+            return Promise.reject('cannot edit incompatible action type or uploading actions');
+        }
+        const data = action.data;
+        data.body.fields = { ...data.body.fields, ...fields };
+        await this.draftQueue.updateDraftAction(action);
+        return this.buildDraftQueueItem(action);
+    }
     buildDraftQueueItem(action) {
         const operationType = getOperationTypeFrom(action);
         const { id, status, timestamp, targetId, metadata } = action;
@@ -1860,6 +1962,18 @@ class DraftManager {
             return this.buildDraftQueueItem(updatedAction);
         });
     }
+    /**
+     * Retries a draft action that is in error state without any modification.
+     *
+     * @param actionId The id of the draft action that should be retried
+     * @throws If the draft action is not at the front of the draft queue or is not
+     * in error state.
+     */
+    async retryAction(actionId) {
+        return this.draftQueue.retryAction(actionId).then((updatedAction) => {
+            return this.buildDraftQueueItem(updatedAction);
+        });
+    }
 }
 
 function makeEnvironmentDraftAware(luvio, env, durableStore, handlers, draftQueue) {

package/dist/types/DraftManager.d.ts

@@ -1,6 +1,8 @@
 import type { CustomActionResult } from './actionHandlers/CustomActionHandler';
-import type { DraftActionStatus, DraftQueue, DraftActionMetadata } from './DraftQueue';
+import type { DraftQueue, DraftAction, DraftActionMetadata, PendingDraftAction } from './DraftQueue';
+import { DraftActionStatus } from './DraftQueue';
 import { DraftQueueState } from './DraftQueue';
+import type { ResourceRequest } from '@luvio/engine';
 /**
  * Representation of the current state of the draft queue.
  * Includes the overall state as well as a list of draft
@@ -14,6 +16,9 @@ export type DraftQueueItemMetadata = {
     [key: string]: string;
 };
 export type DraftManagerCustomActionExecutor = (item: DraftQueueItem, completed: (result: CustomActionResult) => void) => void;
+export type FieldMap = {
+    [key: string]: string | number | null | boolean;
+};
 /**
  * An item in the draft queue that loosely maps to
  * a DraftAction
@@ -124,6 +129,10 @@ export declare class DraftManager {
      * @returns
      */
     setCustomActionExecutor(handlerId: string, executor: DraftManagerCustomActionExecutor): Promise<() => Promise<void>>;
+    mergePerformQuickAction(actionId: string, fields: FieldMap): Promise<DraftQueueItem>;
+    private isValidFieldMap;
+    isPerformQuickActionDraft(action: DraftAction<unknown, unknown>, method: string): action is PendingDraftAction<ResourceRequest>;
+    mergePerformUpdateRecordQuickAction(actionId: string, fields: FieldMap): Promise<DraftQueueItem>;
     private buildDraftQueueItem;
     private callListeners;
     /**
@@ -162,4 +171,12 @@ export declare class DraftManager {
      * @param metadata The metadata to set on the specified action
      */
     setMetadata(actionId: string, metadata: DraftQueueItemMetadata): Promise<DraftQueueItem>;
+    /**
+     * Retries a draft action that is in error state without any modification.
+     *
+     * @param actionId The id of the draft action that should be retried
+     * @throws If the draft action is not at the front of the draft queue or is not
+     * in error state.
+     */
+    retryAction(actionId: string): Promise<DraftQueueItem>;
 }

package/dist/types/DraftQueue.d.ts

@@ -204,6 +204,13 @@ export interface DraftQueue {
      * @param actionId The action identifier
      */
     removeDraftAction(actionId: string): Promise<void>;
+    /**
+     * Saves the specified action into the queue, overwriting previous values
+     * of the action with the new ones
+     *
+     * @param action The action to update with the passed in values
+     */
+    updateDraftAction<Data, Response>(action: DraftAction<Data, Response>): Promise<void>;
     /**
      * Replaces the resource request of `withActionId` for the resource request
      * of `actionId`. Action ids cannot be equal. Both actions must be acting
@@ -228,6 +235,14 @@ export interface DraftQueue {
      * action will be removed after the merge.
      */
     mergeActions<Data, Response>(targetActionId: string, sourceActionId: string): Promise<DraftAction<Data, Response>>;
+    /**
+     * Retries a draft action that is in error state without any modification.
+     *
+     * @param actionId The id of the draft action that should be retried
+     * @throws If the draft action is not at the front of the draft queue or is not
+     * in error state.
+     */
+    retryAction<Data, Response>(actionId: string): Promise<DraftAction<Data, Response>>;
     /** Set the draft queue state to Started and process the next item */
     startQueue(): Promise<void>;
     /** Set the draft queue state to Stopped and don't let another item begin */

package/dist/types/DurableDraftQueue.d.ts

@@ -1,4 +1,4 @@
-import type { DraftQueue, DraftAction, CompletedDraftAction, DraftQueueChangeListener, DraftActionMetadata, EnqueueResult } from './DraftQueue';
+import type { DraftQueue, DraftAction, CompletedDraftAction, PendingDraftAction, DraftQueueChangeListener, DraftActionMetadata, EnqueueResult } from './DraftQueue';
 import { ProcessActionResult, DraftQueueState } from './DraftQueue';
 import type { CustomActionExecutor } from './actionHandlers/CustomActionHandler';
 import type { ActionHandler } from './actionHandlers/ActionHandler';
@@ -45,8 +45,11 @@ export declare class DurableDraftQueue implements DraftQueue {
      */
     private startQueueSafe;
     removeDraftAction(actionId: string): Promise<void>;
+    updateDraftAction<Data>(action: PendingDraftAction<Data>): Promise<void>;
+    private statusOfAction;
     replaceAction<Data, Response>(targetActionId: string, sourceActionId: string): Promise<DraftAction<Data, Response>>;
     mergeActions<Data, Response>(targetActionId: string, sourceActionId: string): Promise<DraftAction<Data, Response>>;
+    retryAction<Data, Response>(actionId: string): Promise<DraftAction<Data, Response>>;
     setMetadata(actionId: string, metadata: DraftActionMetadata): Promise<DraftAction<unknown, unknown>>;
     private scheduleRetryWithSpecifiedDelay;
     private scheduleRetry;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-drafts",
-    "version": "1.303.0",
+    "version": "1.305.0",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "LDS Drafts",
     "main": "dist/ldsDrafts.js",
@@ -26,6 +26,9 @@
     "dependencies": {
         "@luvio/engine": "0.156.3",
         "@luvio/environments": "0.156.3",
-        "@salesforce/lds-utils-adapters": "^1.303.0"
+        "@salesforce/lds-utils-adapters": "^1.305.0"
+    },
+    "volta": {
+        "extends": "../../package.json"
     }
 }