@salesforce/lds-drafts 1.315.0 → 1.317.0

package/dist/ldsDrafts.js

@@ -4,10 +4,9 @@
  * For full license text, see the LICENSE.txt file
  */
 
-import { HttpStatusCode, StoreKeyMap } from '@luvio/engine';
-import { AsyncWorkerPool, uuidv4 } from '@salesforce/lds-utils-adapters';
-import ldsIdempotencyWriteDisabled from '@salesforce/gate/lds.idempotencyWriteDisabled';
-import ldsBackdatingEnabled from '@salesforce/gate/lds.backdatingEnabled';
+import { HttpStatusCode } from '@luvio/engine';
+import { AsyncWorkerPool } from '@salesforce/lds-utils-adapters';
+export { uuidv4 } from '@salesforce/lds-utils-adapters';
 
 var DraftActionStatus;
 (function (DraftActionStatus) {
@@ -385,6 +384,11 @@ class DurableDraftQueue {
         this.userState = DraftQueueState.Stopped;
         this.uploadingActionId = undefined;
         this.timeoutHandler = undefined;
+        this.logger = typeof __nimbus !== 'undefined' &&
+            __nimbus.plugins !== undefined &&
+            __nimbus.plugins.JSLoggerPlugin !== undefined
+            ? __nimbus.plugins.JSLoggerPlugin
+            : undefined;
         this.handlers = {};
         this.draftStore = draftStore;
         this.workerPool = new AsyncWorkerPool(1);
@@ -425,12 +429,13 @@ class DurableDraftQueue {
         await this.notifyChangedListeners({
             type: DraftQueueEventType.QueueStateChanged,
             state: this.state,
+            draftCount: this.draftStore.getCount(),
         });
         const result = await this.processNextAction();
         switch (result) {
             case ProcessActionResult.BLOCKED_ON_ERROR:
                 this.state = DraftQueueState.Error;
-                return Promise.reject();
+                return Promise.reject('Unable to start queue - first action is in error state');
             default:
                 return Promise.resolve();
         }
@@ -441,16 +446,22 @@ class DurableDraftQueue {
             // Do nothing if the queue state is already stopped
             return Promise.resolve();
         }
-        this.stopQueueManually();
+        this.stopQueueManually(false);
         return this.notifyChangedListeners({
             type: DraftQueueEventType.QueueStateChanged,
             state: DraftQueueState.Stopped,
+            draftCount: this.draftStore.getCount(),
         });
     }
     /**
      * Used to stop the queue within DraftQueue without user interaction
      */
-    stopQueueManually() {
+    stopQueueManually(internalReason) {
+        if (this.logger) {
+            this.logger.logInfo(internalReason
+                ? 'Draft queue stopped for internal reason'
+                : 'Draft queue stopped by app');
+        }
         if (this.timeoutHandler) {
             clearTimeout(this.timeoutHandler);
             this.timeoutHandler = undefined;
@@ -460,9 +471,6 @@ class DurableDraftQueue {
     async getQueueActions() {
         const drafts = (await this.draftStore.getAllDrafts());
         const queue = [];
-        if (drafts === undefined) {
-            return queue;
-        }
         drafts.forEach((draft) => {
             if (draft.id === this.uploadingActionId) {
                 draft.status = DraftActionStatus.Uploading;
@@ -493,6 +501,7 @@ class DurableDraftQueue {
                 await this.notifyChangedListeners({
                     type: DraftQueueEventType.ActionAdded,
                     action: pendingAction,
+                    draftCount: this.draftStore.getCount(),
                 });
                 await handler.handleActionEnqueued(pendingAction, queue);
                 if (this.state === DraftQueueState.Started) {
@@ -525,6 +534,7 @@ class DurableDraftQueue {
                 await this.notifyChangedListeners({
                     type: DraftQueueEventType.ActionCompleted,
                     action,
+                    draftCount: this.draftStore.getCount(),
                 });
                 if (this.state === DraftQueueState.Started) {
                     this.processNextAction();
@@ -574,6 +584,7 @@ class DurableDraftQueue {
             await this.notifyChangedListeners({
                 type: DraftQueueEventType.ActionFailed,
                 action: action,
+                draftCount: this.draftStore.getCount(),
             });
             return ProcessActionResult.BLOCKED_ON_ERROR;
         }
@@ -590,6 +601,7 @@ class DurableDraftQueue {
         await this.notifyChangedListeners({
             type: DraftQueueEventType.ActionUploading,
             action: { ...action, status: DraftActionStatus.Uploading },
+            draftCount: this.draftStore.getCount(),
         });
         return this.handle(action);
     }
@@ -611,6 +623,7 @@ class DurableDraftQueue {
         return this.notifyChangedListeners({
             type: DraftQueueEventType.ActionFailed,
             action: errorAction,
+            draftCount: this.draftStore.getCount(),
         });
     }
     async notifyChangedListeners(event) {
@@ -657,6 +670,7 @@ class DurableDraftQueue {
         await this.notifyChangedListeners({
             type: DraftQueueEventType.ActionDeleted,
             action,
+            draftCount: this.draftStore.getCount(),
         });
         if (this.userState === DraftQueueState.Started &&
             this.state !== DraftQueueState.Started &&
@@ -666,7 +680,7 @@ class DurableDraftQueue {
     }
     async updateDraftAction(action) {
         // stop queue manually
-        this.stopQueueManually();
+        this.stopQueueManually(true);
         const actionStatus = await this.statusOfAction(action.id);
         if (actionStatus === DraftActionStatus.Uploading) {
             return Promise.reject('cannot update an uploading action');
@@ -696,7 +710,7 @@ class DurableDraftQueue {
         return this.replaceOrMergeActions(targetActionId, sourceActionId, true);
     }
     async retryAction(actionId) {
-        this.stopQueueManually();
+        this.stopQueueManually(true);
         const actions = await this.getQueueActions();
         const target = actions[0];
         if (!target || target.id !== actionId) {
@@ -714,6 +728,7 @@ class DurableDraftQueue {
         await this.notifyChangedListeners({
             type: DraftQueueEventType.ActionUpdated,
             action: pendingAction,
+            draftCount: this.draftStore.getCount(),
         });
         await this.startQueueSafe();
         return pendingAction;
@@ -739,6 +754,7 @@ class DurableDraftQueue {
         await this.notifyChangedListeners({
             type: DraftQueueEventType.ActionUpdated,
             action: action,
+            draftCount: this.draftStore.getCount(),
         });
         return action;
     }
@@ -746,6 +762,7 @@ class DurableDraftQueue {
         await this.notifyChangedListeners({
             type: DraftQueueEventType.QueueStateChanged,
             state: DraftQueueState.Waiting,
+            draftCount: this.draftStore.getCount(),
         });
         this.timeoutHandler = setTimeout(() => {
             if (this.state !== DraftQueueState.Stopped) {
@@ -804,7 +821,7 @@ class DurableDraftQueue {
         if (this.replacingAction !== undefined) {
             throw Error('Cannot replace/merge actions while a replace/merge action operation is in progress.');
         }
-        this.stopQueueManually();
+        this.stopQueueManually(true);
         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
@@ -820,6 +837,7 @@ class DurableDraftQueue {
                 await this.notifyChangedListeners({
                     type: DraftQueueEventType.ActionUpdated,
                     action: updatedTarget,
+                    draftCount: this.draftStore.getCount(),
                 });
                 // remove the source from queue
                 await this.removeDraftAction(sourceActionId);
@@ -958,6 +976,9 @@ class DurableDraftStore {
         };
         return this.enqueueAction(action);
     }
+    getCount() {
+        return keys(this.draftStore).length;
+    }
     /**
      * Runs a write operation against the draft store, if the initial
      * revive is still in progress, the action gets enqueued to run once the
@@ -1001,23 +1022,15 @@ class DurableDraftStore {
                 for (let i = 0, len = keys$1.length; i < len; i++) {
                     const entry = durableEntries[keys$1[i]];
                     const action = entry.data;
-                    if (action !== undefined) {
-                        if (process.env.NODE_ENV !== 'production') {
-                            // the `version` property was introduced in 242, we should assert version
-                            // exists once we are sure there are no durable stores that contain
-                            // versionless actions
-                            if (action.version && action.version !== '242.0.0') {
-                                return Promise.reject('Unexpected draft action version found in the durable store');
-                            }
-                        }
-                        draftStore[action.id] = action;
-                    }
-                    else {
-                        if (process.env.NODE_ENV !== 'production') {
-                            const err = new Error('Expected draft action to be defined in the durable store');
-                            return Promise.reject(err);
+                    if (process.env.NODE_ENV !== 'production') {
+                        // the `version` property was introduced in 242, we should assert version
+                        // exists once we are sure there are no durable stores that contain
+                        // versionless actions
+                        if (action.version && action.version !== '242.0.0') {
+                            return Promise.reject('Unexpected draft action version found in the durable store');
                         }
                     }
+                    draftStore[action.id] = action;
                 }
                 return this.runQueuedOperations();
             })
@@ -1053,494 +1066,6 @@ class DurableDraftStore {
     }
 }
 
-const HTTP_HEADER_RETRY_AFTER = 'Retry-After';
-const HTTP_HEADER_IDEMPOTENCY_KEY = 'Idempotency-Key';
-const ERROR_CODE_IDEMPOTENCY_FEATURE_NOT_ENABLED = 'IDEMPOTENCY_FEATURE_NOT_ENABLED';
-const ERROR_CODE_IDEMPOTENCY_NOT_SUPPORTED = 'IDEMPOTENCY_NOT_SUPPORTED';
-const ERROR_CODE_IDEMPOTENCY_KEY_USED_DIFFERENT_USER = 'IDEMPOTENCY_KEY_USED_DIFFERENT_USER';
-const ERROR_CODE_IDEMPOTENCY_CONCURRENT_REQUEST = 'IDEMPOTENCY_CONCURRENT_REQUEST';
-const ERROR_CODE_IDEMPOTENCY_KEY_ALREADY_USED = 'IDEMPOTENCY_KEY_ALREADY_USED';
-const ERROR_CODE_IDEMPOTENCY_BACKEND_OPERATION_ERROR = 'IDEMPOTENCY_BACKEND_OPERATION_ERROR';
-/**
- * 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();
-}
-
-const DEFAULT_FIELD_LAST_MODIFIED_DATE = 'LastModifiedDate';
-const DEFAULT_FIELD_CREATED_DATE = 'CreatedDate';
-class AbstractResourceRequestActionHandler {
-    constructor(draftQueue, networkAdapter, getLuvio) {
-        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 = {};
-        // determined by Server setup.
-        this.isIdempotencySupported = true;
-        // idempotency write flag set by lds
-        this.isLdsIdempotencyWriteDisabled = ldsIdempotencyWriteDisabled.isOpen({
-            fallback: false,
-        });
-        this.isBackdatingEnabled = ldsBackdatingEnabled.isOpen({ fallback: false });
-    }
-    enqueue(data) {
-        return this.draftQueue.enqueue(this.handlerId, data);
-    }
-    async handleAction(action, actionCompleted, actionErrored) {
-        const { data: request } = action;
-        // no context is stored in draft action
-        try {
-            const response = await this.networkAdapter(request, {});
-            if (response.ok) {
-                await actionCompleted({
-                    ...action,
-                    response,
-                    status: DraftActionStatus.Completed,
-                });
-                return ProcessActionResult.ACTION_SUCCEEDED;
-            }
-            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;
-                        if (this.handleIdempotencyServerError(response.body, updatedAction, false, ERROR_CODE_IDEMPOTENCY_BACKEND_OPERATION_ERROR)) {
-                            this.isIdempotencySupported = false;
-                            retryDelayInMs = 0;
-                            actionDataChanged = true;
-                        }
-                        break;
-                    }
-                    case 409 /* IdempotentWriteSpecificHttpStatusCode.Conflict */: {
-                        if (this.isUiApiErrors(response.body)) {
-                            const errorCode = response.body[0].errorCode;
-                            if (this.handleIdempotencyServerError(response.body, updatedAction, true, ERROR_CODE_IDEMPOTENCY_KEY_USED_DIFFERENT_USER)) {
-                                retryDelayInMs = 0;
-                                actionDataChanged = true;
-                            }
-                            else if (errorCode === ERROR_CODE_IDEMPOTENCY_CONCURRENT_REQUEST) {
-                                retryDelayInMs = getRetryAfterInMs(response.headers);
-                            }
-                            shouldRetry = true;
-                        }
-                        break;
-                    }
-                    case HttpStatusCode.BadRequest: {
-                        if (this.handleIdempotencyServerError(response.body, updatedAction, false, ERROR_CODE_IDEMPOTENCY_FEATURE_NOT_ENABLED, ERROR_CODE_IDEMPOTENCY_NOT_SUPPORTED)) {
-                            retryDelayInMs = 0;
-                            actionDataChanged = true;
-                            shouldRetry = true;
-                        }
-                        break;
-                    }
-                    case 422 /* IdempotentWriteSpecificHttpStatusCode.UnProcessableEntity */: {
-                        if (this.handleIdempotencyServerError(response.body, updatedAction, true, ERROR_CODE_IDEMPOTENCY_KEY_ALREADY_USED)) {
-                            retryDelayInMs = 0;
-                            actionDataChanged = true;
-                            shouldRetry = true;
-                        }
-                        break;
-                    }
-                }
-            }
-            if (this.isBackdatingEnabled &&
-                response.status === HttpStatusCode.BadRequest &&
-                this.isBackdatingError(response.body, action)) {
-                updatedAction.timestamp = Date.now();
-                updatedAction.data.body.fields = {
-                    ...updatedAction.data.body.fields,
-                    LastModifiedDate: new Date(updatedAction.timestamp).toISOString(),
-                };
-                if (this.hasIdempotencySupport() &&
-                    updatedAction.data.headers[HTTP_HEADER_IDEMPOTENCY_KEY]) {
-                    updatedAction.data.headers[HTTP_HEADER_IDEMPOTENCY_KEY] = uuidv4();
-                }
-                shouldRetry = true;
-                actionDataChanged = true;
-            }
-            await actionErrored(shouldRetry
-                ? updatedAction
-                : {
-                    ...updatedAction,
-                    error: response,
-                    status: DraftActionStatus.Error,
-                }, shouldRetry, retryDelayInMs, actionDataChanged);
-            return ProcessActionResult.ACTION_ERRORED;
-        }
-        catch (e) {
-            await actionErrored(action, true);
-            return ProcessActionResult.NETWORK_ERROR;
-        }
-    }
-    // true if response is an idempotency server error. updates or deletes idempotency key if the reponse is idempotency related error. Idempotency related error is in format of UiApiError array.
-    handleIdempotencyServerError(responseBody, action, updateIdempotencyKey, ...targetErrorCodes) {
-        if (this.isUiApiErrors(responseBody)) {
-            const errorCode = responseBody[0].errorCode;
-            if (targetErrorCodes.includes(errorCode)) {
-                action.data.headers = action.data.headers || {};
-                if (updateIdempotencyKey) {
-                    action.data.headers[HTTP_HEADER_IDEMPOTENCY_KEY] = uuidv4();
-                }
-                else {
-                    delete action.data.headers[HTTP_HEADER_IDEMPOTENCY_KEY];
-                }
-                return true;
-            }
-        }
-        return false;
-    }
-    // checks if the body is an array of UiApiError. Sometimes the body has `enhancedErrorType` field as an error indicator(one example is the field validation failure). In such case Action being processed updates to an Error Action.
-    isUiApiErrors(body) {
-        return body !== undefined && isArray(body) && body.length > 0 && body[0].errorCode;
-    }
-    isBackdatingError(body, action) {
-        if (body.enhancedErrorType &&
-            body.enhancedErrorType === 'RecordError' &&
-            body.output &&
-            body.output.errors &&
-            isArray(body.output.errors) &&
-            body.output.errors.length > 0 &&
-            action.data.body &&
-            action.data.body.fields &&
-            action.data.body.fields[DEFAULT_FIELD_LAST_MODIFIED_DATE]) {
-            return body.output.errors.some((error) => error.errorCode === 'CollisionDetectedException');
-        }
-        return false;
-    }
-    async buildPendingAction(request, queue) {
-        const targetId = await this.getIdFromRequest(request);
-        const tag = this.buildTagForTargetId(targetId);
-        const handlerActions = queue.filter((x) => x.handler === this.handlerId);
-        if (request.method === 'post' && actionsForTag(tag, handlerActions).length > 0) {
-            return Promise.reject(new Error('Cannot enqueue a POST draft action with an existing tag'));
-        }
-        if (deleteActionsForTag(tag, handlerActions).length > 0) {
-            return Promise.reject(new Error('Cannot enqueue a draft action for a deleted record'));
-        }
-        return {
-            handler: this.handlerId,
-            targetId,
-            tag,
-            data: request,
-            status: DraftActionStatus.Pending,
-            id: generateUniqueDraftActionId(queue.map((x) => x.id)),
-            timestamp: Date.now(),
-            metadata: {},
-            version: '242.0.0',
-        };
-    }
-    async handleActionEnqueued(_action) { }
-    handleActionRemoved(action) {
-        return this.reingestRecord(action);
-    }
-    getQueueOperationsForCompletingDrafts(queue, action) {
-        const queueOperations = [];
-        const redirects = this.getRedirectMappings(action);
-        if (redirects !== undefined) {
-            const { length } = queue;
-            for (let i = 0; i < length; i++) {
-                const queueAction = queue[i];
-                // if this queueAction is the action that is completing we can move on,
-                // it is about to be deleted and won't have the draft ID in it
-                if (queueAction.id === action.id) {
-                    continue;
-                }
-                if (isResourceRequestAction(queueAction)) {
-                    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;
-                        }
-                    }
-                    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,
-                            });
-                        }
-                    }
-                }
-            }
-        }
-        // delete completed action
-        queueOperations.push({
-            type: QueueOperationType.Delete,
-            id: action.id,
-        });
-        return queueOperations;
-    }
-    getRedirectMappings(action) {
-        if (action.data.method !== 'post') {
-            return undefined;
-        }
-        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,
-                canonicalId,
-                draftKey: this.buildTagForTargetId(draftId),
-                canonicalKey: this.buildTagForTargetId(canonicalId),
-            },
-        ];
-    }
-    async handleActionCompleted(action, queueOperations, allHandlers) {
-        const { data: request, tag } = action;
-        const { method } = request;
-        if (method === 'delete') {
-            return this.evictKey(tag);
-        }
-        const recordsToIngest = [];
-        recordsToIngest.push({
-            response: action.response.body,
-            synchronousIngest: this.synchronousIngest.bind(this),
-            buildCacheKeysForResponse: this.buildCacheKeysFromResponse.bind(this),
-        });
-        const recordsNeedingReplay = queueOperations.filter((x) => x.type === QueueOperationType.Update);
-        for (const recordNeedingReplay of recordsNeedingReplay) {
-            const { action } = recordNeedingReplay;
-            if (isResourceRequestAction(action)) {
-                // We can't assume the queue operation is for our handler, have to find the handler.
-                const handler = allHandlers.find((h) => h.handlerId === action.handler);
-                if (handler !== undefined) {
-                    const record = await handler.getDataForAction(action);
-                    if (record !== undefined) {
-                        recordsToIngest.push({
-                            response: record,
-                            synchronousIngest: handler.synchronousIngest.bind(handler),
-                            buildCacheKeysForResponse: handler.buildCacheKeysFromResponse.bind(handler),
-                        });
-                    }
-                }
-            }
-        }
-        await this.ingestResponses(recordsToIngest, action);
-    }
-    handleReplaceAction(targetAction, sourceAction) {
-        //reject if the action to replace is a POST action
-        const pendingAction = targetAction;
-        if (pendingAction.data.method === 'post') {
-            throw Error('Cannot replace a POST action');
-        }
-        if (this.isActionOfType(targetAction) &&
-            this.isActionOfType(sourceAction)) {
-            targetAction.status = DraftActionStatus.Pending;
-            targetAction.data = sourceAction.data;
-            return targetAction;
-        }
-        else {
-            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),
-        };
-        // Updates Idempotency key if target has one
-        if (targetData.headers && targetData.headers[HTTP_HEADER_IDEMPOTENCY_KEY]) {
-            merged.data.headers[HTTP_HEADER_IDEMPOTENCY_KEY] = uuidv4();
-        }
-        // overlay metadata
-        merged.metadata = { ...targetMetadata, ...sourceMetadata };
-        // put status back to pending to auto upload if queue is active and targed is at the head.
-        merged.status = DraftActionStatus.Pending;
-        return merged;
-    }
-    shouldDeleteActionByTagOnRemoval(action) {
-        return action.data.method === 'post';
-    }
-    updateMetadata(_existingMetadata, incomingMetadata) {
-        return incomingMetadata;
-    }
-    isActionOfType(action) {
-        return action.handler === this.handlerId;
-    }
-    async reingestRecord(action) {
-        const record = await this.getDataForAction(action);
-        if (record !== undefined) {
-            await this.ingestResponses([
-                {
-                    response: record,
-                    synchronousIngest: this.synchronousIngest.bind(this),
-                    buildCacheKeysForResponse: this.buildCacheKeysFromResponse.bind(this),
-                },
-            ], action);
-        }
-        else {
-            await this.evictKey(action.tag);
-        }
-    }
-    // Given an action for this handler this method should return the draft IDs.
-    // Most of the time it will simply be the targetId, but certain handlers might
-    // have multiple draft-created IDs so they would override this to return them.
-    getDraftIdsFromAction(action) {
-        return [action.targetId];
-    }
-    hasIdempotencySupport() {
-        return this.isIdempotencySupported && !this.isLdsIdempotencyWriteDisabled;
-    }
-    async ingestResponses(responses, action) {
-        const luvio = this.getLuvio();
-        await luvio.handleSuccessResponse(() => {
-            if (action.status === DraftActionStatus.Completed) {
-                const mappings = this.getRedirectMappings(action);
-                if (mappings) {
-                    mappings.forEach((mapping) => {
-                        luvio.storeRedirect(mapping.draftKey, mapping.canonicalKey);
-                    });
-                }
-            }
-            for (const entry of responses) {
-                const { response, synchronousIngest } = entry;
-                synchronousIngest(response, action);
-            }
-            return luvio.storeBroadcast();
-        }, 
-        // getTypeCacheKeysRecord uses the response, not the full path factory
-        // so 2nd parameter will be unused
-        () => {
-            const keySet = new StoreKeyMap();
-            for (const entry of responses) {
-                const { response, buildCacheKeysForResponse } = entry;
-                const set = buildCacheKeysForResponse(response);
-                for (const key of set.keys()) {
-                    const value = set.get(key);
-                    if (value !== undefined) {
-                        keySet.set(key, value);
-                    }
-                }
-            }
-            return keySet;
-        });
-    }
-    async evictKey(key) {
-        const luvio = this.getLuvio();
-        await luvio.handleSuccessResponse(() => {
-            luvio.storeEvict(key);
-            return luvio.storeBroadcast();
-        }, () => {
-            return new StoreKeyMap();
-        });
-    }
-}
-function actionsForTag(tag, queue) {
-    return queue.filter((action) => action.tag === tag);
-}
-function deleteActionsForTag(tag, queue) {
-    return queue.filter((action) => action.tag === tag && action.data.method === 'delete');
-}
-function isResourceRequestAction(action) {
-    const dataAsAny = action.data;
-    return (dataAsAny !== undefined && dataAsAny.method !== undefined && dataAsAny.body !== undefined);
-}
-
 /**
  * Denotes what kind of operation a DraftQueueItem represents.
  */
@@ -1761,16 +1286,17 @@ class DraftManager {
             return Promise.reject('cannot edit incompatible action type or uploading actions');
         }
         action.data.body.fields = { ...action.data.body.fields, ...fields };
+        action.status = DraftActionStatus.Pending;
         await this.draftQueue.updateDraftAction(action);
         return this.buildDraftQueueItem(action);
     }
     isValidFieldMap(fields) {
         const keys$1 = keys(fields);
-        const validTypes = ['string', 'number', 'null', 'boolean'];
+        const validTypes = ['string', 'number', 'boolean'];
         for (let i = 0; i < keys$1.length; i++) {
             const key = keys$1[i];
             const value = fields[key];
-            if (!validTypes.includes(typeof value)) {
+            if (!validTypes.includes(typeof value) && value !== null) {
                 return false;
             }
         }
@@ -1798,6 +1324,7 @@ class DraftManager {
         }
         const data = action.data;
         data.body.fields = { ...data.body.fields, ...fields };
+        action.status = DraftActionStatus.Pending;
         await this.draftQueue.updateDraftAction(action);
         return this.buildDraftQueueItem(action);
     }
@@ -1914,6 +1441,10 @@ class DraftManager {
         });
     }
 }
+function isResourceRequestAction(action) {
+    const dataAsAny = action.data;
+    return (dataAsAny !== undefined && dataAsAny.method !== undefined && dataAsAny.body !== undefined);
+}
 
 function makeEnvironmentDraftAware(luvio, env, durableStore, handlers, draftQueue) {
     const draftMetadata = {};
@@ -2005,4 +1536,4 @@ function makeEnvironmentDraftAware(luvio, env, durableStore, handlers, draftQueu
     });
 }
 
-export { AbstractResourceRequestActionHandler, CustomActionResultType, DEFAULT_FIELD_CREATED_DATE, DEFAULT_FIELD_LAST_MODIFIED_DATE, DRAFT_ERROR_CODE, DRAFT_ID_MAPPINGS_SEGMENT, DRAFT_SEGMENT, DraftActionOperationType, DraftActionStatus, DraftErrorFetchResponse, DraftFetchResponse, DraftManager, DraftQueueEventType, DraftQueueState, DraftSynthesisError, DurableDraftQueue, DurableDraftStore, ProcessActionResult, createBadRequestResponse, createDeletedResponse, createDraftSynthesisErrorResponse, createInternalErrorResponse, createNotFoundResponse, createOkResponse, generateUniqueDraftActionId, isDraftSynthesisError, makeEnvironmentDraftAware, transformErrorToDraftSynthesisError };
+export { CustomActionResultType, DRAFT_ERROR_CODE, DRAFT_ID_MAPPINGS_SEGMENT, DRAFT_SEGMENT, DraftActionOperationType, DraftActionStatus, DraftErrorFetchResponse, DraftFetchResponse, DraftManager, DraftQueueEventType, DraftQueueState, DraftSynthesisError, DurableDraftQueue, DurableDraftStore, ProcessActionResult, QueueOperationType, createBadRequestResponse, createDeletedResponse, createDraftSynthesisErrorResponse, createInternalErrorResponse, createNotFoundResponse, createOkResponse, generateUniqueDraftActionId, isDraftSynthesisError, makeEnvironmentDraftAware, transformErrorToDraftSynthesisError };

package/dist/types/DraftQueue.d.ts

@@ -103,31 +103,36 @@ export declare enum DraftQueueEventType {
      */
     QueueStateChanged = "state"
 }
-export interface DraftQueueAddEvent {
+export interface DraftQueueStats {
+    draftCount: number;
+}
+export interface DraftQueueAddEvent extends DraftQueueStats {
     type: DraftQueueEventType.ActionAdded;
     action: PendingDraftAction<unknown>;
 }
-export interface DraftQueueUploadingEvent {
+export interface DraftQueueUploadingEvent extends DraftQueueStats {
     type: DraftQueueEventType.ActionUploading;
     action: UploadingDraftAction<unknown>;
+    draftCount: number;
 }
-export interface DraftQueueDeleteEvent {
+export interface DraftQueueDeleteEvent extends DraftQueueStats {
     type: DraftQueueEventType.ActionDeleted;
     action: DraftAction<unknown, unknown>;
+    draftCount: number;
 }
-export interface DraftQueueCompleteEvent {
+export interface DraftQueueCompleteEvent extends DraftQueueStats {
     type: DraftQueueEventType.ActionCompleted;
     action: CompletedDraftAction<unknown, unknown>;
 }
-export interface DraftQueueActionFailedEvent {
+export interface DraftQueueActionFailedEvent extends DraftQueueStats {
     type: DraftQueueEventType.ActionFailed;
     action: ErrorDraftAction<unknown>;
 }
-export interface DraftQueueActionUpdatedEvent {
+export interface DraftQueueActionUpdatedEvent extends DraftQueueStats {
     type: DraftQueueEventType.ActionUpdated;
     action: DraftAction<unknown, unknown>;
 }
-export interface DraftQueueStateChangedEvent {
+export interface DraftQueueStateChangedEvent extends DraftQueueStats {
     type: DraftQueueEventType.QueueStateChanged;
     state: DraftQueueState;
 }

package/dist/types/DraftStore.d.ts

@@ -8,4 +8,5 @@ export interface DraftStore {
     deleteDraft(actionId: string): Promise<void>;
     deleteByTag(tag: string): Promise<void>;
     completeAction(queueOperations: QueueOperation[]): Promise<void>;
+    getCount(): number;
 }

package/dist/types/DurableDraftQueue.d.ts

@@ -16,6 +16,7 @@ export declare class DurableDraftQueue implements DraftQueue {
     private replacingAction?;
     private uploadingActionId?;
     private timeoutHandler;
+    private logger;
     private workerPool;
     private handlers;
     private getHandler;

package/dist/types/DurableDraftStore.d.ts

@@ -21,6 +21,7 @@ export declare class DurableDraftStore implements DraftStore {
     deleteDraft(id: string): Promise<void>;
     deleteByTag(tag: string): Promise<void>;
     completeAction(queueOperations: QueueOperation[]): Promise<void>;
+    getCount(): number;
     /**
      * Runs a write operation against the draft store, if the initial
      * revive is still in progress, the action gets enqueued to run once the

package/dist/types/main.d.ts

@@ -1,14 +1,13 @@
-export { DraftQueue, DraftQueueState, DraftAction, ErrorDraftAction, PendingDraftAction, CompletedDraftAction, DraftActionStatus, ProcessActionResult, DraftQueueChangeListener, DraftActionMetadata, DraftQueueEventType, QueueOperation, } from './DraftQueue';
+export { DraftQueue, DraftQueueState, DraftAction, ErrorDraftAction, PendingDraftAction, CompletedDraftAction, DraftActionStatus, ProcessActionResult, DraftQueueChangeListener, DraftActionMetadata, DraftQueueEventType, QueueOperation, UpdateQueueOperation, QueueOperationType, } from './DraftQueue';
 export { DRAFT_ID_MAPPINGS_SEGMENT, DraftKeyMapping } from './DraftIdMapping';
 export { DurableDraftQueue, DRAFT_SEGMENT } from './DurableDraftQueue';
-export { generateUniqueDraftActionId } from './utils/id';
+export { generateUniqueDraftActionId, uuidv4 } from './utils/id';
 export { DurableDraftStore } from './DurableDraftStore';
 export { DraftStore } from './DraftStore';
 export { DraftManager, DraftManagerState, DraftActionOperationType, DraftQueueItem, DraftQueueItemMetadata, } from './DraftManager';
 export { ActionHandler, ReplacingActions, DraftIdAndKeyMapping, } from './actionHandlers/ActionHandler';
 export type { CustomActionResult } from './actionHandlers/CustomActionHandler';
 export { CustomActionResultType, CustomActionExecutor } from './actionHandlers/CustomActionHandler';
-export { AbstractResourceRequestActionHandler, ResponseIngestionEntry, DEFAULT_FIELD_CREATED_DATE, DEFAULT_FIELD_LAST_MODIFIED_DATE, } from './actionHandlers/AbstractResourceRequestActionHandler';
 export { makeEnvironmentDraftAware } from './makeEnvironmentDraftAware';
 export type { DraftAwareEnvironment } from './makeEnvironmentDraftAware';
 export * from './DraftFetchResponse';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-drafts",
-    "version": "1.315.0",
+    "version": "1.317.0",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "LDS Drafts",
     "main": "dist/ldsDrafts.js",
@@ -26,7 +26,10 @@
     "dependencies": {
         "@luvio/engine": "0.156.4",
         "@luvio/environments": "0.156.4",
-        "@salesforce/lds-utils-adapters": "^1.315.0"
+        "@salesforce/lds-utils-adapters": "^1.317.0"
+    },
+    "devDependencies": {
+        "@salesforce/nimbus-plugin-lds": "^1.317.0"
     },
     "volta": {
         "extends": "../../package.json"

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

@@ -1,71 +0,0 @@
-import type { NetworkAdapter, ResourceRequest, Luvio, DurableStoreKeyMetadataMap } from '@luvio/engine';
-import type { DraftAction, CompletedDraftAction, QueueOperation, PendingDraftAction, DraftActionMetadata, DraftQueue } from '../DraftQueue';
-import { ProcessActionResult } from '../DraftQueue';
-import type { ActionHandler, DraftIdAndKeyMapping } from './ActionHandler';
-export type ResponseIngestionEntry<T = unknown> = {
-    response: T;
-    synchronousIngest: AbstractResourceRequestActionHandler<T, unknown>['synchronousIngest'];
-    buildCacheKeysForResponse: AbstractResourceRequestActionHandler<T, unknown>['buildCacheKeysFromResponse'];
-};
-export declare const DEFAULT_FIELD_LAST_MODIFIED_DATE = "LastModifiedDate";
-export declare const DEFAULT_FIELD_CREATED_DATE = "CreatedDate";
-export declare abstract class AbstractResourceRequestActionHandler<ResponseType, DraftMetadata> implements ActionHandler<ResourceRequest, DraftMetadata, ResponseType> {
-    protected readonly draftQueue: DraftQueue;
-    protected readonly networkAdapter: NetworkAdapter;
-    protected readonly getLuvio: () => Luvio;
-    ephemeralRedirects: {
-        [key: string]: string;
-    };
-    isIdempotencySupported: boolean;
-    isLdsIdempotencyWriteDisabled: boolean;
-    isBackdatingEnabled: boolean;
-    constructor(draftQueue: DraftQueue, networkAdapter: NetworkAdapter, getLuvio: () => Luvio);
-    enqueue(data: ResourceRequest): Promise<PendingDraftAction<ResourceRequest>>;
-    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>;
-    handleIdempotencyServerError(responseBody: any, action: DraftAction<ResourceRequest, ResponseType>, updateIdempotencyKey: boolean, ...targetErrorCodes: string[]): boolean;
-    isUiApiErrors(body: any): boolean;
-    isBackdatingError(body: any, action: DraftAction<ResourceRequest, ResponseType>): any;
-    buildPendingAction(request: ResourceRequest, queue: DraftAction<unknown, unknown>[]): Promise<PendingDraftAction<ResourceRequest>>;
-    handleActionEnqueued(_action: PendingDraftAction<ResourceRequest>): Promise<void>;
-    handleActionRemoved(action: DraftAction<ResourceRequest, ResponseType>): Promise<void>;
-    getQueueOperationsForCompletingDrafts(queue: DraftAction<unknown, unknown>[], action: CompletedDraftAction<ResourceRequest, ResponseType>): QueueOperation[];
-    getRedirectMappings(action: CompletedDraftAction<ResourceRequest, ResponseType>): DraftIdAndKeyMapping[] | undefined;
-    handleActionCompleted(action: CompletedDraftAction<ResourceRequest, ResponseType>, queueOperations: QueueOperation[], allHandlers: ActionHandler<unknown, unknown, unknown>[]): Promise<void>;
-    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;
-    protected reingestRecord(action: DraftAction<ResourceRequest, ResponseType>): Promise<void>;
-    getDraftIdsFromAction(action: DraftAction<ResourceRequest, ResponseType>): string[];
-    hasIdempotencySupport(): boolean;
-    ingestResponses(responses: ResponseIngestionEntry[], action: DraftAction<ResourceRequest, ResponseType>): Promise<void>;
-    evictKey(key: string): Promise<void>;
-    abstract handlerId: string;
-    abstract canHandlePublish(key: string): boolean;
-    abstract canRepresentationContainDraftMetadata(representationName: string): boolean;
-    /**
-     * Extracts or synthesizes an id from a given resource request
-     * @throws if the id cannot be determined or synthesized
-     * @param request the request to get the id from
-     */
-    abstract getIdFromRequest(request: ResourceRequest): Promise<string>;
-    abstract getIdFromResponseBody(responseBody: ResponseType): string;
-    abstract buildTagForTargetId(id: string): string;
-    abstract buildCacheKeysFromResponse(response: ResponseType): DurableStoreKeyMetadataMap;
-    abstract synchronousIngest(response: ResponseType, action: DraftAction<ResourceRequest, ResponseType>): void;
-    abstract getDataForAction(action: DraftAction<ResourceRequest, ResponseType>): Promise<ResponseType | undefined>;
-    abstract getDraftMetadata(key: string): Promise<DraftMetadata | undefined>;
-    abstract applyDraftsToIncomingData(key: string, data: unknown, draftMetadata: DraftMetadata | undefined, publishFn: (key: string, data: any) => void): void;
-    /**
-     * Returns true if the given targetId is a for a draft-created record
-     *
-     * @param targetId the targetId to check
-     */
-    abstract isDraftId(targetId: string): boolean;
-    /**
-     * 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/IdempotentWrite.d.ts

@@ -1,33 +0,0 @@
-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,
-    UnProcessableEntity = 422
-}
-/**
- * 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_FEATURE_NOT_ENABLED = "IDEMPOTENCY_FEATURE_NOT_ENABLED";
-export declare const ERROR_CODE_IDEMPOTENCY_NOT_SUPPORTED = "IDEMPOTENCY_NOT_SUPPORTED";
-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";
-export declare const ERROR_CODE_IDEMPOTENCY_KEY_ALREADY_USED = "IDEMPOTENCY_KEY_ALREADY_USED";
-export declare const ERROR_CODE_IDEMPOTENCY_BACKEND_OPERATION_ERROR = "IDEMPOTENCY_BACKEND_OPERATION_ERROR";
-/**
- * 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;