@salesforce/lds-drafts 1.100.3 → 1.100.5

package/dist/DraftQueue.d.ts

@@ -144,15 +144,19 @@ export interface UpdateQueueOperation {
     action: DraftAction<unknown, unknown>;
 }
 export type QueueOperation = UpdateQueueOperation | AddQueueOperation | DeleteQueueOperation;
+export interface EnqueueResult<Data, Response> {
+    action: PendingDraftAction<Data>;
+    data: Response;
+}
 export interface DraftQueue {
     /**
      * Enqueues a draft action into the DraftQueue
      * @param handlerId the id of the handler associated with the data
      * @param data the data the handler will use to create the draft action with
-     * @returns A promise including the pending action created for the request
+     * @returns A promise including the pending action created for the request and the data associated with the action
      * @throws {Error} An error when a proper action handler is not found or conditions are not met to enqueue the action
      */
-    enqueue<Response>(handlerId: string, data: unknown): Promise<PendingDraftAction<Response>>;
+    enqueue<Data, Response>(handlerId: string, data: Data): Promise<EnqueueResult<Data, Response>>;
     /**
      * add a new handler to the draft queue to process the data in the actions
      * @param id identifier to the handler
@@ -225,11 +229,5 @@ export interface DraftQueue {
      * @param metadata The metadata to set on the specified action
      */
     setMetadata(actionId: string, metadata: DraftActionMetadata): Promise<DraftAction<unknown, unknown>>;
-    /**
-     * Gets the data associated with the passed in action. This data will have drafts applied to it
-     * @param action
-     * @returns the data for the given action or undefined if the data no longer exists
-     */
-    getDataForAction<T>(action: DraftAction<T, unknown>): Promise<T | undefined>;
 }
 export {};

package/dist/DurableDraftQueue.d.ts

@@ -1,4 +1,4 @@
-import type { DraftQueue, DraftAction, CompletedDraftAction, PendingDraftAction, DraftQueueChangeListener, DraftActionMetadata } from './DraftQueue';
+import type { DraftQueue, DraftAction, CompletedDraftAction, DraftQueueChangeListener, DraftActionMetadata, EnqueueResult } from './DraftQueue';
 import { ProcessActionResult, DraftQueueState } from './DraftQueue';
 import type { CustomActionExecutor } from './actionHandlers/CustomActionHandler';
 import type { ActionHandler } from './actionHandlers/ActionHandler';
@@ -16,13 +16,13 @@ export declare class DurableDraftQueue implements DraftQueue {
     private replacingAction?;
     private uploadingActionId?;
     private timeoutHandler;
+    private workerPool;
     private handlers;
     private getHandler;
     constructor(draftStore: DraftStore);
     addHandler<Data>(handler: ActionHandler<Data, unknown, unknown>): Promise<void>;
     removeHandler(id: string): Promise<void>;
     addCustomHandler(id: string, executor: CustomActionExecutor): Promise<void>;
-    getDataForAction<T>(action: DraftAction<T, unknown>): Promise<T | undefined>;
     getQueueState(): DraftQueueState;
     startQueue(): Promise<void>;
     stopQueue(): Promise<void>;
@@ -31,7 +31,7 @@ export declare class DurableDraftQueue implements DraftQueue {
      */
     private stopQueueManually;
     getQueueActions<Data = unknown, Response = unknown>(): Promise<DraftAction<Data, Response>[]>;
-    enqueue<Data>(handlerId: string, data: unknown): Promise<PendingDraftAction<Data>>;
+    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>;

package/dist/actionHandlers/AbstractResourceRequestActionHandler.d.ts

@@ -1,5 +1,5 @@
 import type { NetworkAdapter, ResourceRequest, Luvio, DurableStoreKeyMetadataMap } from '@luvio/engine';
-import type { DraftAction, CompletedDraftAction, QueueOperation, PendingDraftAction, DraftActionMetadata, DraftQueue } from '../DraftQueue';
+import type { DraftAction, CompletedDraftAction, QueueOperation, PendingDraftAction, DraftActionMetadata, DraftQueue, EnqueueResult } from '../DraftQueue';
 import { ProcessActionResult } from '../DraftQueue';
 import type { ActionHandler, DraftIdAndKeyMapping, ReplacingActions } from './ActionHandler';
 export type ResponseIngestionEntry<T = unknown> = {
@@ -11,8 +11,11 @@ export declare abstract class AbstractResourceRequestActionHandler<ResponseType,
     protected readonly draftQueue: DraftQueue;
     protected readonly networkAdapter: NetworkAdapter;
     protected readonly getLuvio: () => Luvio;
+    ephemeralRedirects: {
+        [key: string]: string;
+    };
     constructor(draftQueue: DraftQueue, networkAdapter: NetworkAdapter, getLuvio: () => Luvio);
-    enqueue(data: ResourceRequest): Promise<PendingDraftAction<ResourceRequest>>;
+    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>;
     buildPendingAction(request: ResourceRequest, queue: DraftAction<unknown, unknown>[]): Promise<PendingDraftAction<ResourceRequest>>;
     handleActionEnqueued(action: PendingDraftAction<ResourceRequest>): Promise<void>;

package/dist/actionHandlers/ActionHandler.d.ts

@@ -1,4 +1,4 @@
-import type { CompletedDraftAction, DraftAction, DraftActionMetadata, PendingDraftAction, ProcessActionResult, QueueOperation } from '../DraftQueue';
+import type { CompletedDraftAction, DraftAction, DraftActionMetadata, EnqueueResult, PendingDraftAction, ProcessActionResult, QueueOperation } from '../DraftQueue';
 import type { DraftKeyMapping } from '../DraftIdMapping';
 export interface ReplacingActions<Response, Data> {
     original: DraftAction<Response, Data>;
@@ -36,7 +36,7 @@ export interface ActionHandler<Data, DraftMetadata, Type> {
      * Enqueues an action to the draft queue
      * @param data the data that will get added to the draft action
      */
-    enqueue(data: Data): Promise<PendingDraftAction<Data>>;
+    enqueue(data: Data): Promise<EnqueueResult<Data, Type>>;
     /**
      * Used to build a PendingDraftAction that is specific to the type of Data and Response.
      * @param data

package/dist/ldsDrafts.js

@@ -5,6 +5,7 @@
  */
 
 import { HttpStatusCode, StoreKeyMap } from '@luvio/engine';
+import { AsyncWorkerPool } from '@salesforce/lds-utils-adapters';
 
 var DraftActionStatus;
 (function (DraftActionStatus) {
@@ -190,14 +191,13 @@ const { isArray } = Array;
 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 action = await handler.enqueue(resourceRequest).catch((err) => {
+        const { data } = await handler.enqueue(resourceRequest).catch((err) => {
             throw transformErrorToDraftSynthesisError(err);
         });
-        const record = await handler.getDataForAction(action);
-        if (record === undefined) {
+        if (data === undefined) {
             return Promise.reject(createDraftSynthesisErrorResponse());
         }
-        return createOkResponse(record);
+        return createOkResponse(data);
     };
     // override this to use an infinitely large ttl so the cache entry never expires
     const publishStoreMetadata = function (key, storeMetadataParams) {
@@ -424,6 +424,7 @@ class DurableDraftQueue {
         this.timeoutHandler = undefined;
         this.handlers = {};
         this.draftStore = draftStore;
+        this.workerPool = new AsyncWorkerPool(1);
     }
     addHandler(handler) {
         const id = handler.handlerId;
@@ -441,10 +442,6 @@ class DurableDraftQueue {
         const handler = customActionHandler(executor, id, this);
         return this.addHandler(handler);
     }
-    async getDataForAction(action) {
-        const handler = this.getHandler(action.handler);
-        return handler.getDataForAction(action);
-    }
     getQueueState() {
         return this.state;
     }
@@ -523,20 +520,26 @@ class DurableDraftQueue {
         });
     }
     async enqueue(handlerId, data) {
-        let queue = await this.getQueueActions();
-        const handler = this.getHandler(handlerId);
-        const pendingAction = (await handler.buildPendingAction(data, queue));
-        await this.draftStore.writeAction(pendingAction);
-        queue = await this.getQueueActions();
-        await this.notifyChangedListeners({
-            type: DraftQueueEventType.ActionAdded,
-            action: pendingAction,
+        return this.workerPool.push(async () => {
+            let queue = await this.getQueueActions();
+            const handler = this.getHandler(handlerId);
+            const pendingAction = (await handler.buildPendingAction(data, queue));
+            await this.draftStore.writeAction(pendingAction);
+            queue = await this.getQueueActions();
+            await this.notifyChangedListeners({
+                type: DraftQueueEventType.ActionAdded,
+                action: pendingAction,
+            });
+            await handler.handleActionEnqueued(pendingAction, queue);
+            if (this.state === DraftQueueState.Started) {
+                this.processNextAction();
+            }
+            const actionData = (await handler.getDataForAction(pendingAction));
+            return {
+                action: pendingAction,
+                data: actionData,
+            };
         });
-        await handler.handleActionEnqueued(pendingAction, queue);
-        if (this.state === DraftQueueState.Started) {
-            this.processNextAction();
-        }
-        return pendingAction;
     }
     registerOnChangedListener(listener) {
         this.draftQueueChangedListeners.push(listener);
@@ -548,27 +551,29 @@ class DurableDraftQueue {
         };
     }
     async actionCompleted(action) {
-        const handler = this.getHandler(action.handler);
-        let queue = await this.getQueueActions();
-        const queueOperations = handler.getQueueOperationsForCompletingDrafts(queue, action);
-        const idAndKeyMappings = handler.getRedirectMappings(action);
-        const keyMappings = idAndKeyMappings === undefined
-            ? undefined
-            : idAndKeyMappings.map((m) => {
-                return { draftKey: m.draftKey, canonicalKey: m.canonicalKey };
+        return this.workerPool.push(async () => {
+            const handler = this.getHandler(action.handler);
+            let queue = await this.getQueueActions();
+            const queueOperations = handler.getQueueOperationsForCompletingDrafts(queue, action);
+            const idAndKeyMappings = handler.getRedirectMappings(action);
+            const keyMappings = idAndKeyMappings === undefined
+                ? undefined
+                : idAndKeyMappings.map((m) => {
+                    return { draftKey: m.draftKey, canonicalKey: m.canonicalKey };
+                });
+            await this.draftStore.completeAction(queueOperations, keyMappings);
+            queue = await this.getQueueActions();
+            this.retryIntervalMilliseconds = 0;
+            this.uploadingActionId = undefined;
+            await handler.handleActionCompleted(action, queueOperations, queue, values(this.handlers));
+            await this.notifyChangedListeners({
+                type: DraftQueueEventType.ActionCompleted,
+                action,
             });
-        await this.draftStore.completeAction(queueOperations, keyMappings);
-        queue = await this.getQueueActions();
-        this.retryIntervalMilliseconds = 0;
-        this.uploadingActionId = undefined;
-        await handler.handleActionCompleted(action, queueOperations, queue, values(this.handlers));
-        await this.notifyChangedListeners({
-            type: DraftQueueEventType.ActionCompleted,
-            action,
+            if (this.state === DraftQueueState.Started) {
+                this.processNextAction();
+            }
         });
-        if (this.state === DraftQueueState.Started) {
-            this.processNextAction();
-        }
     }
     async actionFailed(action, retry) {
         this.uploadingActionId = undefined;
@@ -1018,6 +1023,13 @@ class AbstractResourceRequestActionHandler {
         this.draftQueue = draftQueue;
         this.networkAdapter = networkAdapter;
         this.getLuvio = getLuvio;
+        // NOTE[W-12567340]: This property stores in-memory mappings between draft
+        // ids and canonical ids for the current session. Having a local copy of
+        // these mappings is necessary to avoid a race condition between publishing
+        // new mappings to the durable store and those mappings being loaded into
+        // the luvio store redirect table, during which a new draft might be enqueued
+        // which would not see a necessary mapping.
+        this.ephemeralRedirects = {};
     }
     enqueue(data) {
         return this.draftQueue.enqueue(this.handlerId, data);
@@ -1085,7 +1097,8 @@ class AbstractResourceRequestActionHandler {
     }
     getQueueOperationsForCompletingDrafts(queue, action) {
         const queueOperations = [];
-        if (action.data.method === 'post') {
+        const redirects = this.getRedirectMappings(action);
+        if (redirects !== undefined) {
             const { length } = queue;
             for (let i = 0; i < length; i++) {
                 const queueAction = queue[i];
@@ -1095,69 +1108,64 @@ class AbstractResourceRequestActionHandler {
                     continue;
                 }
                 if (isResourceRequestAction(queueAction)) {
-                    const redirects = this.getRedirectMappings(action);
-                    if (redirects !== undefined) {
-                        let queueOperationMutated = false;
-                        let updatedActionTag = undefined;
-                        let updatedActionTargetId = undefined;
-                        const { tag: queueActionTag, data: queueActionRequest, id: queueActionId, } = queueAction;
-                        let { basePath, body } = queueActionRequest;
-                        let stringifiedBody = stringify(body);
-                        // for each redirected ID/key we loop over the operation to see if it needs
-                        // to be updated
-                        for (const { draftId, draftKey, canonicalId, canonicalKey } of redirects) {
-                            if (basePath.search(draftId) >= 0 ||
-                                stringifiedBody.search(draftId) >= 0) {
-                                basePath = basePath.replace(draftId, canonicalId);
-                                stringifiedBody = stringifiedBody.replace(draftId, canonicalId);
-                                queueOperationMutated = true;
-                            }
-                            // if the action is performed on a previous draft id, we need to replace the action
-                            // with a new one at the updated canonical key
-                            if (queueActionTag === draftKey) {
-                                updatedActionTag = canonicalKey;
-                                updatedActionTargetId = canonicalId;
-                            }
+                    let queueOperationMutated = false;
+                    let updatedActionTag = undefined;
+                    let updatedActionTargetId = undefined;
+                    const { tag: queueActionTag, data: queueActionRequest, id: queueActionId, } = queueAction;
+                    let { basePath, body } = queueActionRequest;
+                    let stringifiedBody = stringify(body);
+                    // for each redirected ID/key we loop over the operation to see if it needs
+                    // to be updated
+                    for (const { draftId, draftKey, canonicalId, canonicalKey } of redirects) {
+                        if (basePath.search(draftId) >= 0 || stringifiedBody.search(draftId) >= 0) {
+                            basePath = basePath.replace(draftId, canonicalId);
+                            stringifiedBody = stringifiedBody.replace(draftId, canonicalId);
+                            queueOperationMutated = true;
                         }
-                        if (queueOperationMutated) {
-                            if (updatedActionTag !== undefined &&
-                                updatedActionTargetId !== undefined) {
-                                const updatedAction = {
-                                    ...queueAction,
-                                    tag: updatedActionTag,
-                                    targetId: updatedActionTargetId,
-                                    data: {
-                                        ...queueActionRequest,
-                                        basePath: basePath,
-                                        body: parse(stringifiedBody),
-                                    },
-                                };
-                                // item needs to be replaced with a new item at the new record key
-                                queueOperations.push({
-                                    type: QueueOperationType.Delete,
-                                    id: queueActionId,
-                                });
-                                queueOperations.push({
-                                    type: QueueOperationType.Add,
-                                    action: updatedAction,
-                                });
-                            }
-                            else {
-                                const updatedAction = {
-                                    ...queueAction,
-                                    data: {
-                                        ...queueActionRequest,
-                                        basePath: basePath,
-                                        body: parse(stringifiedBody),
-                                    },
-                                };
-                                // item needs to be updated
-                                queueOperations.push({
-                                    type: QueueOperationType.Update,
-                                    id: queueActionId,
-                                    action: updatedAction,
-                                });
-                            }
+                        // if the action is performed on a previous draft id, we need to replace the action
+                        // with a new one at the updated canonical key
+                        if (queueActionTag === draftKey) {
+                            updatedActionTag = canonicalKey;
+                            updatedActionTargetId = canonicalId;
+                        }
+                    }
+                    if (queueOperationMutated) {
+                        if (updatedActionTag !== undefined && updatedActionTargetId !== undefined) {
+                            const updatedAction = {
+                                ...queueAction,
+                                tag: updatedActionTag,
+                                targetId: updatedActionTargetId,
+                                data: {
+                                    ...queueActionRequest,
+                                    basePath: basePath,
+                                    body: parse(stringifiedBody),
+                                },
+                            };
+                            // item needs to be replaced with a new item at the new record key
+                            queueOperations.push({
+                                type: QueueOperationType.Delete,
+                                id: queueActionId,
+                            });
+                            queueOperations.push({
+                                type: QueueOperationType.Add,
+                                action: updatedAction,
+                            });
+                        }
+                        else {
+                            const updatedAction = {
+                                ...queueAction,
+                                data: {
+                                    ...queueActionRequest,
+                                    basePath: basePath,
+                                    body: parse(stringifiedBody),
+                                },
+                            };
+                            // item needs to be updated
+                            queueOperations.push({
+                                type: QueueOperationType.Update,
+                                id: queueActionId,
+                                action: updatedAction,
+                            });
                         }
                     }
                 }
@@ -1177,6 +1185,9 @@ class AbstractResourceRequestActionHandler {
         const body = action.response.body;
         const canonicalId = this.getIdFromResponseBody(body);
         const draftId = action.targetId;
+        if (draftId !== undefined && canonicalId !== undefined && draftId !== canonicalId) {
+            this.ephemeralRedirects[draftId] = canonicalId;
+        }
         return [
             {
                 draftId,
@@ -1471,7 +1482,9 @@ class DraftManager {
             targetId,
             tag,
         })
-            .then(this.buildDraftQueueItem);
+            .then((result) => {
+            return this.buildDraftQueueItem(result.action);
+        });
     }
     /**
      * Get the current state of each of the DraftActions in the DraftQueue

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-drafts",
-    "version": "1.100.3",
+    "version": "1.100.5",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "LDS Drafts",
     "main": "dist/ldsDrafts.js",
@@ -25,6 +25,7 @@
     },
     "dependencies": {
         "@luvio/engine": "0.135.4",
-        "@luvio/environments": "0.135.4"
+        "@luvio/environments": "0.135.4",
+        "@salesforce/lds-utils-adapters": "^1.100.5"
     }
 }