@salesforce/lds-drafts 1.124.4 → 1.124.5

package/dist/ldsDrafts.js

@@ -367,10 +367,6 @@ function customActionHandler(executor, id, draftQueue) {
         });
         return queueOperations;
     };
-    const replaceAction = (actionId, _withActionId, _uploadingActionId, _actions) => {
-        // eslint-disable-next-line @salesforce/lds/no-error-in-production
-        throw new Error(`${actionId} does not support action replacing. You can only delete ${actionId}`);
-    };
     const getRedirectMappings = (_action) => {
         return undefined;
     };
@@ -382,7 +378,9 @@ function customActionHandler(executor, id, draftQueue) {
         handleAction: handle,
         buildPendingAction,
         getQueueOperationsForCompletingDrafts: getQueueOperationsForCompletingDrafts,
-        handleReplaceAction: replaceAction,
+        handleReplaceAction: () => {
+            throw Error('replaceAction not supported for custom actions');
+        },
         getRedirectMappings,
         handleActionRemoved: () => Promise.resolve(),
         handleActionCompleted: () => Promise.resolve(),
@@ -449,13 +447,13 @@ class DurableDraftQueue {
         this.userState = DraftQueueState.Started;
         if (this.state === DraftQueueState.Started) {
             // Do nothing if the queue state is already started
-            return Promise.resolve();
+            return;
         }
         if (this.replacingAction !== undefined) {
             // If we're replacing an action do nothing
             // replace will restart the queue for us as long as the user
             // has last set the queue to be started
-            return Promise.resolve();
+            return;
         }
         this.retryIntervalMilliseconds = 0;
         this.state = DraftQueueState.Started;
@@ -695,92 +693,11 @@ class DurableDraftQueue {
             await this.startQueue();
         }
     }
-    replaceAction(actionId, withActionId) {
-        // ids must be unique
-        if (actionId === withActionId) {
-            return Promise.reject('Swapped and swapping action ids cannot be the same');
-        }
-        // cannot have a replace action already in progress
-        if (this.replacingAction !== undefined) {
-            return Promise.reject('Cannot replace actions while a replace action is in progress');
-        }
-        this.stopQueueManually();
-        const replacing = this.getQueueActions().then(async (actions) => {
-            const first = actions.filter((action) => action.id === actionId)[0];
-            if (first === undefined) {
-                this.replacingAction = undefined;
-                await this.startQueueSafe();
-                return Promise.reject('No action to replace');
-            }
-            // put in a try/finally block so we don't leave this.replacingAction
-            // indefinitely set
-            let actionToReplace;
-            try {
-                const replaceResult = this.getHandler(first.handler).handleReplaceAction(actionId, withActionId, this.uploadingActionId, actions);
-                actionToReplace = replaceResult.actionToReplace;
-                // TODO [W-8873834]: Will add batching support to durable store
-                // we should use that here to remove and set both actions in one operation
-                await this.removeDraftAction(replaceResult.replacingAction.id);
-                await this.draftStore.writeAction(actionToReplace);
-                await this.notifyChangedListeners({
-                    type: DraftQueueEventType.ActionUpdated,
-                    action: actionToReplace,
-                });
-            }
-            finally {
-                this.replacingAction = undefined;
-            }
-            await this.startQueueSafe();
-            return actionToReplace;
-        });
-        this.replacingAction = replacing;
-        return replacing;
+    replaceAction(targetActionId, sourceActionId) {
+        return this.replaceOrMergeActions(targetActionId, sourceActionId, false);
     }
     mergeActions(targetActionId, sourceActionId) {
-        // ids must be unique
-        if (targetActionId === sourceActionId) {
-            return Promise.reject(new Error('targetActionId and sourceActionId cannot be the same.'));
-        }
-        // cannot have a replace action already in progress
-        if (this.replacingAction !== undefined) {
-            return Promise.reject(new Error('Cannot merge actions while a replace/merge action operation is in progress.'));
-        }
-        this.stopQueueManually();
-        const promise = this.getQueueActions().then(async (actions) => {
-            const target = actions.find((action) => action.id === targetActionId);
-            if (target === undefined) {
-                this.replacingAction = undefined;
-                await this.startQueueSafe();
-                throw Error('targetActionId not found in the draft queue.');
-            }
-            const source = actions.find((action) => action.id === sourceActionId);
-            if (source === undefined) {
-                this.replacingAction = undefined;
-                await this.startQueueSafe();
-                throw Error('sourceActionId not found in the draft queue.');
-            }
-            // put in a try/finally block so we don't leave this.replacingAction
-            // indefinitely set
-            let merged;
-            try {
-                merged = this.getHandler(target.handler).mergeActions(target, source);
-                // update the target
-                await this.draftStore.writeAction(merged);
-                await this.notifyChangedListeners({
-                    type: DraftQueueEventType.ActionUpdated,
-                    action: merged,
-                });
-                // remove the source from queue
-                await this.removeDraftAction(sourceActionId);
-            }
-            finally {
-                this.replacingAction = undefined;
-            }
-            await this.startQueueSafe();
-            return merged;
-        });
-        this.replacingAction = promise;
-        return promise;
+        return this.replaceOrMergeActions(targetActionId, sourceActionId, true);
     }
     async setMetadata(actionId, metadata) {
         const keys$1 = keys(metadata);
@@ -815,6 +732,81 @@ class DurableDraftQueue {
             }
         }, this.retryIntervalMilliseconds);
     }
+    async getActionsForReplaceOrMerge(targetActionId, sourceActionId) {
+        const actions = await this.getQueueActions();
+        const target = actions.find((action) => action.id === targetActionId);
+        if (target === undefined) {
+            this.replacingAction = undefined;
+            await this.startQueueSafe();
+            throw Error(`targetActionId ${targetActionId} not found in the draft queue.`);
+        }
+        const source = actions.find((action) => action.id === sourceActionId);
+        if (source === undefined) {
+            this.replacingAction = undefined;
+            await this.startQueueSafe();
+            throw Error(`sourceActionId ${sourceActionId} not found in the draft queue.`);
+        }
+        return { target, source };
+    }
+    assertReplaceOrMergePrerequisites(target, source) {
+        // ensure actions are in a state to be replaced/merged
+        const { targetId: targetCacheKey, tag: targetTag, status: targetStatus, version: targetVersion, } = target;
+        const { targetId: sourceCacheKey, tag: sourceTag, status: sourceStatus, version: sourceVersion, } = source;
+        if (targetCacheKey !== sourceCacheKey) {
+            throw Error('Cannot replace/merge actions for different targetIds.');
+        }
+        if (targetTag !== sourceTag) {
+            throw Error('Cannot replace/merge actions for different tags.');
+        }
+        if (targetStatus === DraftActionStatus.Completed ||
+            targetStatus === DraftActionStatus.Uploading) {
+            throw Error(`Cannot replace/merge actions when targetAction is in ${targetStatus} status.`);
+        }
+        if (sourceStatus !== DraftActionStatus.Pending) {
+            throw Error(`Cannot replace/merge actions when sourceAction is in ${sourceStatus} status.`);
+        }
+        if (targetVersion !== sourceVersion) {
+            throw Error('Cannot replace/merge actions with different versions.');
+        }
+    }
+    async replaceOrMergeActions(targetActionId, sourceActionId, merge) {
+        // ids must be unique
+        if (targetActionId === sourceActionId) {
+            throw Error('targetActionId and sourceActionId cannot be the same.');
+        }
+        // cannot have a replace action already in progress
+        if (this.replacingAction !== undefined) {
+            throw Error('Cannot replace/merge actions while a replace/merge action operation is in progress.');
+        }
+        this.stopQueueManually();
+        const promise = this.getActionsForReplaceOrMerge(targetActionId, sourceActionId).then(async ({ target, source }) => {
+            // put in a try/finally block so we don't leave this.replacingAction
+            // indefinitely set
+            let updatedTarget;
+            try {
+                this.assertReplaceOrMergePrerequisites(target, source);
+                const handler = this.getHandler(target.handler);
+                updatedTarget = merge
+                    ? handler.mergeActions(target, source)
+                    : handler.handleReplaceAction(target, source);
+                // update the target
+                await this.draftStore.writeAction(updatedTarget);
+                await this.notifyChangedListeners({
+                    type: DraftQueueEventType.ActionUpdated,
+                    action: updatedTarget,
+                });
+                // remove the source from queue
+                await this.removeDraftAction(sourceActionId);
+            }
+            finally {
+                this.replacingAction = undefined;
+                await this.startQueueSafe();
+            }
+            return updatedTarget;
+        });
+        this.replacingAction = promise;
+        return promise;
+    }
 }
 
 const DRAFT_ACTION_KEY_JUNCTION = '__DraftAction__';
@@ -1248,55 +1240,52 @@ class AbstractResourceRequestActionHandler {
         }
         await this.ingestResponses(recordsToIngest, action);
     }
-    handleReplaceAction(actionId, withActionId, uploadingActionId, actions) {
-        // get the action to replace
-        const actionToReplace = actions.filter((action) => action.id === actionId)[0];
-        // get the replacing action
-        const replacingAction = actions.filter((action) => action.id === withActionId)[0];
-        // reject if either action is undefined
-        if (actionToReplace === undefined || replacingAction === undefined) {
-            // eslint-disable-next-line @salesforce/lds/no-error-in-production
-            throw new Error('One or both actions does not exist');
-        }
-        // reject if either action is uploading
-        if (actionToReplace.id === uploadingActionId || replacingAction.id === uploadingActionId) {
-            // eslint-disable-next-line @salesforce/lds/no-error-in-production
-            throw new Error('Cannot replace an draft action that is uploading');
-        }
-        // reject if these two draft actions aren't acting on the same target
-        if (actionToReplace.tag !== replacingAction.tag) {
-            // eslint-disable-next-line @salesforce/lds/no-error-in-production
-            throw new Error('Cannot swap actions targeting different targets');
-        }
-        // reject if the replacing action is not pending
-        if (replacingAction.status !== DraftActionStatus.Pending) {
-            // eslint-disable-next-line @salesforce/lds/no-error-in-production
-            throw new Error('Cannot replace with a non-pending action');
-        }
+    handleReplaceAction(targetAction, sourceAction) {
         //reject if the action to replace is a POST action
-        const pendingAction = actionToReplace;
+        const pendingAction = targetAction;
         if (pendingAction.data.method === 'post') {
-            // eslint-disable-next-line @salesforce/lds/no-error-in-production
-            throw new Error('Cannot replace a POST action');
+            throw Error('Cannot replace a POST action');
         }
-        if (this.isActionOfType(actionToReplace) &&
-            this.isActionOfType(replacingAction)) {
-            const actionToReplaceCopy = {
-                ...actionToReplace,
-                status: DraftActionStatus.Pending,
-            };
-            actionToReplace.status = DraftActionStatus.Pending;
-            actionToReplace.data = replacingAction.data;
-            return {
-                original: actionToReplaceCopy,
-                actionToReplace: actionToReplace,
-                replacingAction: replacingAction,
-            };
+        if (this.isActionOfType(targetAction) &&
+            this.isActionOfType(sourceAction)) {
+            targetAction.status = DraftActionStatus.Pending;
+            targetAction.data = sourceAction.data;
+            return targetAction;
         }
         else {
-            // eslint-disable-next-line @salesforce/lds/no-error-in-production
-            throw new Error('Incompatible Action types to replace one another');
-        }
+            throw Error('Incompatible Action types to replace one another');
+        }
+    }
+    mergeActions(targetAction, sourceAction) {
+        const { id: targetId, data: targetData, metadata: targetMetadata, timestamp: targetTimestamp, } = targetAction;
+        const { method: targetMethod, body: targetBody } = targetData;
+        const { data: sourceData, metadata: sourceMetadata } = sourceAction;
+        const { method: sourceMethod, body: sourceBody } = sourceData;
+        if (targetMethod.toLowerCase() === 'delete' || sourceMethod.toLowerCase() === 'delete') {
+            throw Error('Cannot merge DELETE actions.');
+        }
+        if (targetMethod.toLowerCase() === 'patch' && sourceMethod.toLowerCase() === 'post') {
+            // overlaying a POST over a PATCH is not supported
+            throw Error('Cannot merge a POST action over top of a PATCH action.');
+        }
+        // overlay top-level properties, maintain target's timestamp and id
+        const merged = {
+            ...targetAction,
+            ...sourceAction,
+            timestamp: targetTimestamp,
+            id: targetId,
+        };
+        // overlay data
+        // NOTE: we stick to the target's ResourceRequest properties (except body
+        // which is merged) because we don't want to overwrite a POST with a PATCH
+        // (all other cases should be fine or wouldn't have passed pre-requisites)
+        merged.data = {
+            ...targetData,
+            body: this.mergeRequestBody(targetBody, sourceBody),
+        };
+        // overlay metadata
+        merged.metadata = { ...targetMetadata, ...sourceMetadata };
+        return merged;
     }
     shouldDeleteActionByTagOnRemoval(action) {
         return action.data.method === 'post';

package/dist/types/DraftQueue.d.ts

@@ -201,10 +201,13 @@ export interface DraftQueue {
      * of `actionId`. Action ids cannot be equal. Both actions must be acting
      * on the same target object, and neither can currently be in progress.
      *
-     * @param actionId The id of the draft action to replace
-     * @param withActionId The id of the draft action that will replace the other
+     * @param targetActionId The draft action id of the target action. This action
+     * will be replaced by the source action while maintaining its position in
+     * the queue.
+     * @param sourceActionId The draft action id of the source action. This
+     * action will replace the target action and will be removed from the queue.
      */
-    replaceAction(actionId: string, withActionId: string): Promise<DraftAction<unknown, unknown>>;
+    replaceAction<Data, Response>(targetActionId: string, sourceActionId: string): Promise<DraftAction<Data, Response>>;
     /**
      * Merges two actions into a single target action. The target action maintains
      * its position in the queue, while the source action is removed from the queue.

package/dist/types/DurableDraftQueue.d.ts

@@ -45,8 +45,11 @@ export declare class DurableDraftQueue implements DraftQueue {
      */
     private startQueueSafe;
     removeDraftAction(actionId: string): Promise<void>;
-    replaceAction(actionId: string, withActionId: string): Promise<DraftAction<unknown, unknown>>;
+    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 scheduleRetry;
+    private getActionsForReplaceOrMerge;
+    private assertReplaceOrMergePrerequisites;
+    private replaceOrMergeActions;
 }

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

@@ -1,7 +1,7 @@
 import type { NetworkAdapter, ResourceRequest, Luvio, DurableStoreKeyMetadataMap } from '@luvio/engine';
 import type { DraftAction, CompletedDraftAction, QueueOperation, PendingDraftAction, DraftActionMetadata, DraftQueue, EnqueueResult } from '../DraftQueue';
 import { ProcessActionResult } from '../DraftQueue';
-import type { ActionHandler, DraftIdAndKeyMapping, ReplacingActions } from './ActionHandler';
+import type { ActionHandler, DraftIdAndKeyMapping } from './ActionHandler';
 export type ResponseIngestionEntry<T = unknown> = {
     response: T;
     synchronousIngest: AbstractResourceRequestActionHandler<T, unknown>['synchronousIngest'];
@@ -23,7 +23,8 @@ export declare abstract class AbstractResourceRequestActionHandler<ResponseType,
     getQueueOperationsForCompletingDrafts(queue: DraftAction<unknown, unknown>[], action: CompletedDraftAction<ResourceRequest, ResponseType>): QueueOperation[];
     getRedirectMappings(action: CompletedDraftAction<ResourceRequest, ResponseType>): DraftIdAndKeyMapping[] | undefined;
     handleActionCompleted(action: CompletedDraftAction<ResourceRequest, ResponseType>, queueOperations: QueueOperation[], _queue: DraftAction<unknown, unknown>[], allHandlers: ActionHandler<unknown, unknown, unknown>[]): Promise<void>;
-    handleReplaceAction<Response>(actionId: string, withActionId: string, uploadingActionId: String | undefined, actions: DraftAction<unknown, unknown>[]): ReplacingActions<ResourceRequest, Response>;
+    handleReplaceAction(targetAction: DraftAction<ResourceRequest, ResponseType>, sourceAction: DraftAction<ResourceRequest, ResponseType>): DraftAction<ResourceRequest, ResponseType>;
+    mergeActions(targetAction: DraftAction<ResourceRequest, ResponseType>, sourceAction: DraftAction<ResourceRequest, ResponseType>): DraftAction<ResourceRequest, ResponseType>;
     shouldDeleteActionByTagOnRemoval(action: DraftAction<ResourceRequest, ResponseType>): boolean;
     updateMetadata(_existingMetadata: DraftActionMetadata, incomingMetadata: DraftActionMetadata): DraftActionMetadata;
     private isActionOfType;
@@ -48,6 +49,9 @@ export declare abstract class AbstractResourceRequestActionHandler<ResponseType,
      * @param targetId the targetId to check
      */
     abstract isDraftId(targetId: string): boolean;
-    abstract mergeActions(targetAction: DraftAction<ResourceRequest, ResponseType>, sourceAction: DraftAction<ResourceRequest, ResponseType>): DraftAction<ResourceRequest, ResponseType>;
+    /**
+     * Overlay the sourceBody over top of the targetBody
+     */
+    abstract mergeRequestBody<T = unknown>(targetBody: T, sourceBody: T): T;
 }
 export declare function isResourceRequestAction(action: DraftAction<unknown, unknown>): action is DraftAction<ResourceRequest, unknown>;

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

@@ -87,13 +87,19 @@ export interface ActionHandler<Data, DraftMetadata, Type> {
      */
     handleActionCompleted(action: CompletedDraftAction<Data, Type>, queueOperations: QueueOperation[], queue: DraftAction<unknown, unknown>[], allHandlers: ActionHandler<unknown, unknown, unknown>[]): Promise<void>;
     /**
-     * Replace an item in the queue with another to take its place (if supported by handler)
-     * @param actionId
-     * @param withActionId
-     * @param uploadingActionId
-     * @param actions
+     * Replace the targetAction's data with the sourceAction's data and return
+     * the targetAction.  Also sets the targetAction's status to Pending.
+     *
+     * NOTE: this method mutates the targetAction.
+     *
+     * Implementations can assume the caller has already ensured the given draft
+     * actions have the same targetId, same tag, same version, and are not currently
+     * being uploaded.
+     *
+     * Replacing draft actions with different targetIds or different tags will result
+     * in an error.
      */
-    handleReplaceAction<Response>(actionId: string, withActionId: string, uploadingActionId: string | undefined, actions: DraftAction<unknown, unknown>[]): ReplacingActions<Data, Response>;
+    handleReplaceAction(targetAction: DraftAction<Data, Type>, sourceAction: DraftAction<Data, Type>): DraftAction<Data, Type>;
     /**
      * Invoked by the durable store and the draft environment to get the data that is associated with this draft action
      * The data should include all drafts applied to it (if any)
@@ -140,8 +146,9 @@ export interface ActionHandler<Data, DraftMetadata, Type> {
      * both actions will be combined, if there are conflicts the source's data will
      * be used).
      *
-     * Merging draft actions with different targetIds or different tags will result
-     * in an error.
+     * Implementations can assume the caller has already ensured the given draft
+     * actions have the same targetId, same tag, same version, and are not currently
+     * being uploaded.
      *
      * NOTE: the resulting merged action will use the target's timestamp and id.
      */

package/package.json

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