@salesforce/lds-drafts 1.302.0 → 1.304.0

package/dist/ldsDrafts.js

@@ -669,7 +669,7 @@ class DurableDraftQueue {
         if (status === DraftActionStatus.Error) {
             this.state = DraftQueueState.Error;
             this.processingAction = undefined;
-            this.notifyChangedListeners({
+            await this.notifyChangedListeners({
                 type: DraftQueueEventType.ActionFailed,
                 action: action,
             });
@@ -685,7 +685,7 @@ class DurableDraftQueue {
         if (this.state === DraftQueueState.Waiting) {
             this.state = DraftQueueState.Started;
         }
-        this.notifyChangedListeners({
+        await this.notifyChangedListeners({
             type: DraftQueueEventType.ActionUploading,
             action: { ...action, status: DraftActionStatus.Uploading },
         });
@@ -762,6 +762,31 @@ 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);
     }
@@ -792,17 +817,21 @@ class DurableDraftQueue {
         });
         return action;
     }
-    scheduleRetryWithSpecifiedDelay(retryDelayInMs) {
+    async scheduleRetryWithSpecifiedDelay(retryDelayInMs) {
+        await this.notifyChangedListeners({
+            type: DraftQueueEventType.QueueStateChanged,
+            state: DraftQueueState.Waiting,
+        });
         this.timeoutHandler = setTimeout(() => {
             if (this.state !== DraftQueueState.Stopped) {
                 this.processNextAction();
             }
         }, retryDelayInMs);
     }
-    scheduleRetry() {
+    async scheduleRetry() {
         const newInterval = this.retryIntervalMilliseconds * 2;
         this.retryIntervalMilliseconds = Math.min(Math.max(newInterval, this.minimumRetryInterval), this.maximumRetryInterval);
-        this.scheduleRetryWithSpecifiedDelay(this.retryIntervalMilliseconds);
+        return this.scheduleRetryWithSpecifiedDelay(this.retryIntervalMilliseconds);
     }
     async getActionsForReplaceOrMerge(targetActionId, sourceActionId) {
         const actions = await this.getQueueActions();
@@ -928,7 +957,8 @@ class DurableDraftStore {
             const actionArray = [];
             for (let i = 0, len = keys$1.length; i < len; i++) {
                 const key = keys$1[i];
-                actionArray.push(draftStore[key]);
+                // clone draft so we don't expose the internal draft store
+                actionArray.push(clone(draftStore[key]));
             }
             return actionArray;
         });
@@ -1577,6 +1607,7 @@ var DraftQueueOperationType;
     DraftQueueOperationType["ItemUpdated"] = "updated";
     DraftQueueOperationType["QueueStarted"] = "started";
     DraftQueueOperationType["QueueStopped"] = "stopped";
+    DraftQueueOperationType["QueueWaiting"] = "waiting";
 })(DraftQueueOperationType || (DraftQueueOperationType = {}));
 /**
  * Converts the internal DraftAction's ResourceRequest into
@@ -1619,6 +1650,16 @@ function toQueueState(queue) {
     };
 }
 class DraftManager {
+    shouldEmitEvent(event) {
+        // Waiting events cannot be emitted prior to 252 native clients
+        // TODO [W-16102411]: we can safely remove this backwards compatible code in 256
+        if (isDraftQueueStateChangeEvent(event) &&
+            event.state === DraftQueueState.Waiting &&
+            this.listenerVersion === undefined) {
+            return false;
+        }
+        return this.draftEventsShouldBeEmitted.includes(event.type);
+    }
     constructor(draftQueue) {
         this.listeners = [];
         this.draftEventsShouldBeEmitted = [
@@ -1632,7 +1673,7 @@ class DraftManager {
         ];
         this.draftQueue = draftQueue;
         draftQueue.registerOnChangedListener((event) => {
-            if (this.draftEventsShouldBeEmitted.includes(event.type)) {
+            if (this.shouldEmitEvent(event)) {
                 return this.callListeners(event);
             }
             return Promise.resolve();
@@ -1662,6 +1703,8 @@ class DraftManager {
                 return DraftQueueOperationType.QueueStarted;
             case DraftQueueState.Stopped:
                 return DraftQueueOperationType.QueueStopped;
+            case DraftQueueState.Waiting:
+                return DraftQueueOperationType.QueueWaiting;
             default:
                 throw Error('Unsupported event type');
         }
@@ -1719,7 +1762,8 @@ class DraftManager {
      *
      * @param listener The listener closure to subscribe to changes
      */
-    registerDraftQueueChangedListener(listener) {
+    registerDraftQueueChangedListener(listener, version = undefined) {
+        this.listenerVersion = version;
         this.listeners.push(listener);
         return () => {
             this.listeners = this.listeners.filter((l) => {
@@ -1746,6 +1790,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;

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
@@ -68,7 +73,8 @@ export declare enum DraftQueueOperationType {
     ItemFailed = "failed",
     ItemUpdated = "updated",
     QueueStarted = "started",
-    QueueStopped = "stopped"
+    QueueStopped = "stopped",
+    QueueWaiting = "waiting"
 }
 /**
  * A closure that draft queue change listeners pass to
@@ -78,7 +84,9 @@ export declare type DraftQueueListener = (state: DraftManagerState, operationTyp
 export declare class DraftManager {
     private draftQueue;
     private listeners;
+    private listenerVersion;
     private draftEventsShouldBeEmitted;
+    private shouldEmitEvent;
     constructor(draftQueue: DraftQueue);
     private draftQueueEventTypeToOperationType;
     private draftQueueStateToOperationType;
@@ -113,7 +121,7 @@ export declare class DraftManager {
      *
      * @param listener The listener closure to subscribe to changes
      */
-    registerDraftQueueChangedListener(listener: DraftQueueListener): () => Promise<void>;
+    registerDraftQueueChangedListener(listener: DraftQueueListener, version?: 252 | undefined): () => Promise<void>;
     /**
      * Creates a custom action handler for the given handler
      * @param handlerId
@@ -121,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;
     /**

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

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,6 +45,8 @@ 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>>;
     setMetadata(actionId: string, metadata: DraftActionMetadata): Promise<DraftAction<unknown, unknown>>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-drafts",
-    "version": "1.302.0",
+    "version": "1.304.0",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "LDS Drafts",
     "main": "dist/ldsDrafts.js",
@@ -24,8 +24,11 @@
         "release:corejar": "yarn build && ../core-build/scripts/core.js --adapter=lds-drafts"
     },
     "dependencies": {
-        "@luvio/engine": "0.155.1",
-        "@luvio/environments": "0.155.1",
-        "@salesforce/lds-utils-adapters": "^1.302.0"
+        "@luvio/engine": "0.156.3",
+        "@luvio/environments": "0.156.3",
+        "@salesforce/lds-utils-adapters": "^1.304.0"
+    },
+    "volta": {
+        "extends": "../../package.json"
     }
 }