@salesforce/lds-drafts 1.124.2 → 1.124.3

package/dist/ldsDrafts.js

@@ -7,1743 +7,1743 @@
 import { HttpStatusCode, StoreKeyMap } from '@luvio/engine';
 import { AsyncWorkerPool } from '@salesforce/lds-utils-adapters';
 
-var DraftActionStatus;
-(function (DraftActionStatus) {
-    DraftActionStatus["Pending"] = "pending";
-    DraftActionStatus["Uploading"] = "uploading";
-    DraftActionStatus["Error"] = "error";
-    DraftActionStatus["Completed"] = "completed";
-})(DraftActionStatus || (DraftActionStatus = {}));
-function isDraftError(draft) {
-    return draft.status === DraftActionStatus.Error;
-}
-function isDraftQueueStateChangeEvent(event) {
-    return event.type === DraftQueueEventType.QueueStateChanged;
-}
-var ProcessActionResult;
-(function (ProcessActionResult) {
-    // non-2xx network error, requires user intervention
-    ProcessActionResult["ACTION_ERRORED"] = "ERROR";
-    // upload succeeded
-    ProcessActionResult["ACTION_SUCCEEDED"] = "SUCCESS";
-    // queue is empty
-    ProcessActionResult["NO_ACTION_TO_PROCESS"] = "NO_ACTION_TO_PROCESS";
-    // network request is in flight
-    ProcessActionResult["ACTION_ALREADY_PROCESSING"] = "ACTION_ALREADY_PROCESSING";
-    // network call failed (offline)
-    ProcessActionResult["NETWORK_ERROR"] = "NETWORK_ERROR";
-    // queue is blocked on an error that requires user intervention
-    ProcessActionResult["BLOCKED_ON_ERROR"] = "BLOCKED_ON_ERROR";
-    //waiting for user to execute custom action
-    ProcessActionResult["CUSTOM_ACTION_WAITING"] = "CUSTOM_ACTION_WAITING";
-})(ProcessActionResult || (ProcessActionResult = {}));
-var DraftQueueState;
-(function (DraftQueueState) {
-    /** Currently processing an item in the queue or queue is empty and waiting to process the next item. */
-    DraftQueueState["Started"] = "started";
-    /**
-     * The queue is stopped and will not attempt to upload any drafts until startDraftQueue() is called.
-     * This is the initial state when the DraftQueue gets instantiated.
-     */
-    DraftQueueState["Stopped"] = "stopped";
-    /**
-     * The queue is stopped due to a blocking error from the last upload attempt.
-     * The queue will not run again until startDraftQueue() is called.
-     */
-    DraftQueueState["Error"] = "error";
-    /**
-     * There was a network error and the queue will attempt to upload again shortly.
-     * To attempt to force an upload now call startDraftQueue().
-     */
-    DraftQueueState["Waiting"] = "waiting";
-})(DraftQueueState || (DraftQueueState = {}));
-var DraftQueueEventType;
-(function (DraftQueueEventType) {
-    /**
-     * Triggered after an action had been added to the queue
-     */
-    DraftQueueEventType["ActionAdded"] = "added";
-    /**
-     * Triggered once an action failed
-     */
-    DraftQueueEventType["ActionFailed"] = "failed";
-    /**
-     * Triggered after an action has been deleted from the queue
-     */
-    DraftQueueEventType["ActionDeleted"] = "deleted";
-    /**
-     * Triggered after an action has been completed and after it has been removed from the queue
-     */
-    DraftQueueEventType["ActionCompleted"] = "completed";
-    /**
-     * Triggered after an action has been updated by the updateAction API
-     */
-    DraftQueueEventType["ActionUpdated"] = "updated";
-    /**
-     * Triggered after the Draft Queue state changes
-     */
-    DraftQueueEventType["QueueStateChanged"] = "state";
-})(DraftQueueEventType || (DraftQueueEventType = {}));
-var QueueOperationType;
-(function (QueueOperationType) {
-    QueueOperationType["Add"] = "add";
-    QueueOperationType["Delete"] = "delete";
-    QueueOperationType["Update"] = "update";
+var DraftActionStatus;
+(function (DraftActionStatus) {
+    DraftActionStatus["Pending"] = "pending";
+    DraftActionStatus["Uploading"] = "uploading";
+    DraftActionStatus["Error"] = "error";
+    DraftActionStatus["Completed"] = "completed";
+})(DraftActionStatus || (DraftActionStatus = {}));
+function isDraftError(draft) {
+    return draft.status === DraftActionStatus.Error;
+}
+function isDraftQueueStateChangeEvent(event) {
+    return event.type === DraftQueueEventType.QueueStateChanged;
+}
+var ProcessActionResult;
+(function (ProcessActionResult) {
+    // non-2xx network error, requires user intervention
+    ProcessActionResult["ACTION_ERRORED"] = "ERROR";
+    // upload succeeded
+    ProcessActionResult["ACTION_SUCCEEDED"] = "SUCCESS";
+    // queue is empty
+    ProcessActionResult["NO_ACTION_TO_PROCESS"] = "NO_ACTION_TO_PROCESS";
+    // network request is in flight
+    ProcessActionResult["ACTION_ALREADY_PROCESSING"] = "ACTION_ALREADY_PROCESSING";
+    // network call failed (offline)
+    ProcessActionResult["NETWORK_ERROR"] = "NETWORK_ERROR";
+    // queue is blocked on an error that requires user intervention
+    ProcessActionResult["BLOCKED_ON_ERROR"] = "BLOCKED_ON_ERROR";
+    //waiting for user to execute custom action
+    ProcessActionResult["CUSTOM_ACTION_WAITING"] = "CUSTOM_ACTION_WAITING";
+})(ProcessActionResult || (ProcessActionResult = {}));
+var DraftQueueState;
+(function (DraftQueueState) {
+    /** Currently processing an item in the queue or queue is empty and waiting to process the next item. */
+    DraftQueueState["Started"] = "started";
+    /**
+     * The queue is stopped and will not attempt to upload any drafts until startDraftQueue() is called.
+     * This is the initial state when the DraftQueue gets instantiated.
+     */
+    DraftQueueState["Stopped"] = "stopped";
+    /**
+     * The queue is stopped due to a blocking error from the last upload attempt.
+     * The queue will not run again until startDraftQueue() is called.
+     */
+    DraftQueueState["Error"] = "error";
+    /**
+     * There was a network error and the queue will attempt to upload again shortly.
+     * To attempt to force an upload now call startDraftQueue().
+     */
+    DraftQueueState["Waiting"] = "waiting";
+})(DraftQueueState || (DraftQueueState = {}));
+var DraftQueueEventType;
+(function (DraftQueueEventType) {
+    /**
+     * Triggered after an action had been added to the queue
+     */
+    DraftQueueEventType["ActionAdded"] = "added";
+    /**
+     * Triggered once an action failed
+     */
+    DraftQueueEventType["ActionFailed"] = "failed";
+    /**
+     * Triggered after an action has been deleted from the queue
+     */
+    DraftQueueEventType["ActionDeleted"] = "deleted";
+    /**
+     * Triggered after an action has been completed and after it has been removed from the queue
+     */
+    DraftQueueEventType["ActionCompleted"] = "completed";
+    /**
+     * Triggered after an action has been updated by the updateAction API
+     */
+    DraftQueueEventType["ActionUpdated"] = "updated";
+    /**
+     * Triggered after the Draft Queue state changes
+     */
+    DraftQueueEventType["QueueStateChanged"] = "state";
+})(DraftQueueEventType || (DraftQueueEventType = {}));
+var QueueOperationType;
+(function (QueueOperationType) {
+    QueueOperationType["Add"] = "add";
+    QueueOperationType["Delete"] = "delete";
+    QueueOperationType["Update"] = "update";
 })(QueueOperationType || (QueueOperationType = {}));
 
-class DraftSynthesisError extends Error {
-    constructor(message, errorType) {
-        super(message);
-        this.errorType = errorType;
-    }
-}
-function isDraftSynthesisError(error) {
-    return error.errorType !== undefined;
+class DraftSynthesisError extends Error {
+    constructor(message, errorType) {
+        super(message);
+        this.errorType = errorType;
+    }
+}
+function isDraftSynthesisError(error) {
+    return error.errorType !== undefined;
 }
 
-const DRAFT_ERROR_CODE = 'DRAFT_ERROR';
-class DraftFetchResponse {
-    constructor(status, body) {
-        this.headers = {};
-        this.status = status;
-        this.body = body;
-    }
-    get statusText() {
-        const { status } = this;
-        switch (status) {
-            case HttpStatusCode.Ok:
-                return 'OK';
-            case HttpStatusCode.Created:
-                return 'Created';
-            case HttpStatusCode.NoContent:
-                return 'No Content';
-            case HttpStatusCode.BadRequest:
-                return 'Bad Request';
-            case HttpStatusCode.ServerError:
-                return 'Server Error';
-            default:
-                return `Unexpected HTTP Status Code: ${status}`;
-        }
-    }
-    get ok() {
-        return this.status >= 200 && this.status < 300;
-    }
-}
-class DraftErrorFetchResponse {
-    constructor(status, body) {
-        this.ok = false;
-        this.headers = {};
-        this.errorType = 'fetchResponse';
-        this.status = status;
-        this.body = body;
-    }
-    get statusText() {
-        const { status } = this;
-        switch (status) {
-            case HttpStatusCode.BadRequest:
-                return 'Bad Request';
-            case HttpStatusCode.ServerError:
-                return 'Server Error';
-            case HttpStatusCode.NotFound:
-                return 'Not Found';
-            default:
-                return `Unexpected HTTP Status Code: ${status}`;
-        }
-    }
-}
-function createOkResponse(body) {
-    return new DraftFetchResponse(HttpStatusCode.Ok, body);
-}
-function createBadRequestResponse(body) {
-    return new DraftErrorFetchResponse(HttpStatusCode.BadRequest, body);
-}
-function createNotFoundResponse(body) {
-    return new DraftErrorFetchResponse(HttpStatusCode.NotFound, body);
-}
-function transformErrorToDraftSynthesisError(error) {
-    if (isDraftSynthesisError(error)) {
-        const { errorType, message } = error;
-        return createDraftSynthesisErrorResponse(message, errorType);
-    }
-    return createDraftSynthesisErrorResponse(error.message);
-}
-function createDraftSynthesisErrorResponse(message = 'failed to synthesize draft response', errorType) {
-    const error = {
-        errorCode: DRAFT_ERROR_CODE,
-        message: message,
-    };
-    if (errorType !== undefined) {
-        error.errorType = errorType;
-    }
-    return new DraftErrorFetchResponse(HttpStatusCode.BadRequest, error);
-}
-function createDeletedResponse() {
-    return new DraftFetchResponse(HttpStatusCode.NoContent, undefined);
-}
-function createInternalErrorResponse() {
-    return new DraftErrorFetchResponse(HttpStatusCode.ServerError, undefined);
+const DRAFT_ERROR_CODE = 'DRAFT_ERROR';
+class DraftFetchResponse {
+    constructor(status, body) {
+        this.headers = {};
+        this.status = status;
+        this.body = body;
+    }
+    get statusText() {
+        const { status } = this;
+        switch (status) {
+            case HttpStatusCode.Ok:
+                return 'OK';
+            case HttpStatusCode.Created:
+                return 'Created';
+            case HttpStatusCode.NoContent:
+                return 'No Content';
+            case HttpStatusCode.BadRequest:
+                return 'Bad Request';
+            case HttpStatusCode.ServerError:
+                return 'Server Error';
+            default:
+                return `Unexpected HTTP Status Code: ${status}`;
+        }
+    }
+    get ok() {
+        return this.status >= 200 && this.status < 300;
+    }
+}
+class DraftErrorFetchResponse {
+    constructor(status, body) {
+        this.ok = false;
+        this.headers = {};
+        this.errorType = 'fetchResponse';
+        this.status = status;
+        this.body = body;
+    }
+    get statusText() {
+        const { status } = this;
+        switch (status) {
+            case HttpStatusCode.BadRequest:
+                return 'Bad Request';
+            case HttpStatusCode.ServerError:
+                return 'Server Error';
+            case HttpStatusCode.NotFound:
+                return 'Not Found';
+            default:
+                return `Unexpected HTTP Status Code: ${status}`;
+        }
+    }
+}
+function createOkResponse(body) {
+    return new DraftFetchResponse(HttpStatusCode.Ok, body);
+}
+function createBadRequestResponse(body) {
+    return new DraftErrorFetchResponse(HttpStatusCode.BadRequest, body);
+}
+function createNotFoundResponse(body) {
+    return new DraftErrorFetchResponse(HttpStatusCode.NotFound, body);
+}
+function transformErrorToDraftSynthesisError(error) {
+    if (isDraftSynthesisError(error)) {
+        const { errorType, message } = error;
+        return createDraftSynthesisErrorResponse(message, errorType);
+    }
+    return createDraftSynthesisErrorResponse(error.message);
+}
+function createDraftSynthesisErrorResponse(message = 'failed to synthesize draft response', errorType) {
+    const error = {
+        errorCode: DRAFT_ERROR_CODE,
+        message: message,
+    };
+    if (errorType !== undefined) {
+        error.errorType = errorType;
+    }
+    return new DraftErrorFetchResponse(HttpStatusCode.BadRequest, error);
+}
+function createDeletedResponse() {
+    return new DraftFetchResponse(HttpStatusCode.NoContent, undefined);
+}
+function createInternalErrorResponse() {
+    return new DraftErrorFetchResponse(HttpStatusCode.ServerError, undefined);
 }
 
-const { keys, create, assign, values } = Object;
-const { stringify, parse } = JSON;
+const { keys, create, assign, values } = Object;
+const { stringify, parse } = JSON;
 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 { data } = await handler.enqueue(resourceRequest).catch((err) => {
-            throw transformErrorToDraftSynthesisError(err);
-        });
-        if (data === undefined) {
-            return Promise.reject(createDraftSynthesisErrorResponse());
-        }
-        return createOkResponse(data);
-    };
-    // override this to use an infinitely large ttl so the cache entry never expires
-    const publishStoreMetadata = function (key, storeMetadataParams) {
-        // if we aren't publishing a draft then use base luvio method
-        const id = extractTargetIdFromCacheKey(key);
-        if (id === undefined || !handler.isDraftId(id)) {
-            return luvio.publishStoreMetadata(key, storeMetadataParams);
-        }
-        return luvio.publishStoreMetadata(key, {
-            ...storeMetadataParams,
-            ttl: Number.MAX_SAFE_INTEGER,
-        });
-    };
-    if (options.forDeleteAdapter === true) {
-        // delete adapters attempt to evict the record on successful network response,
-        // since draft-aware delete adapters do soft-delete (record stays in cache
-        // with a "drafts.deleted" property) we want storeEvict to just be a no-op
-        const storeEvict = function (_key) {
-            // no-op
-        };
-        return create(luvio, {
-            dispatchResourceRequest: { value: dispatchResourceRequest },
-            publishStoreMetadata: { value: publishStoreMetadata },
-            storeEvict: { value: storeEvict },
-        });
-    }
-    return create(luvio, {
-        dispatchResourceRequest: { value: dispatchResourceRequest },
-        publishStoreMetadata: { value: publishStoreMetadata },
-    });
+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 { data } = await handler.enqueue(resourceRequest).catch((err) => {
+            throw transformErrorToDraftSynthesisError(err);
+        });
+        if (data === undefined) {
+            return Promise.reject(createDraftSynthesisErrorResponse());
+        }
+        return createOkResponse(data);
+    };
+    // override this to use an infinitely large ttl so the cache entry never expires
+    const publishStoreMetadata = function (key, storeMetadataParams) {
+        // if we aren't publishing a draft then use base luvio method
+        const id = extractTargetIdFromCacheKey(key);
+        if (id === undefined || !handler.isDraftId(id)) {
+            return luvio.publishStoreMetadata(key, storeMetadataParams);
+        }
+        return luvio.publishStoreMetadata(key, {
+            ...storeMetadataParams,
+            ttl: Number.MAX_SAFE_INTEGER,
+        });
+    };
+    if (options.forDeleteAdapter === true) {
+        // delete adapters attempt to evict the record on successful network response,
+        // since draft-aware delete adapters do soft-delete (record stays in cache
+        // with a "drafts.deleted" property) we want storeEvict to just be a no-op
+        const storeEvict = function (_key) {
+            // no-op
+        };
+        return create(luvio, {
+            dispatchResourceRequest: { value: dispatchResourceRequest },
+            publishStoreMetadata: { value: publishStoreMetadata },
+            storeEvict: { value: storeEvict },
+        });
+    }
+    return create(luvio, {
+        dispatchResourceRequest: { value: dispatchResourceRequest },
+        publishStoreMetadata: { value: publishStoreMetadata },
+    });
 }
 
-const DraftIdMappingKeyPrefix240 = 'DraftIdMapping::';
-const DraftKeyMappingKeyPrefix = 'DraftKeyMapping::V2::';
-const DRAFT_ID_MAPPINGS_SEGMENT = 'DRAFT_ID_MAPPINGS';
-function isLegacyDraftIdMapping(key, data) {
-    return key.startsWith(DraftIdMappingKeyPrefix240);
-}
-// TODO [W-11677776]: in 242 we changed the format to store keys instead of ids
-// this can be removed when we drop support for id storing
-function getRecordKeyForId(id) {
-    return `UiApi::RecordRepresentation:${id}`;
-}
-function generateDraftIdMappingKey(draftIdMapping) {
-    return `${DraftKeyMappingKeyPrefix}${draftIdMapping.draftKey}::${draftIdMapping.canonicalKey}`;
-}
-/**
- *
- * @param mappingIds (optional) requested mapping ids, if undefined all will be retrieved
- */
-async function getDraftIdMappings(durableStore, mappingIds) {
-    const mappings = [];
-    let durableStoreOperation;
-    if (mappingIds === undefined) {
-        durableStoreOperation =
-            durableStore.getAllEntries(DRAFT_ID_MAPPINGS_SEGMENT);
-    }
-    else {
-        durableStoreOperation = durableStore.getEntries(mappingIds, DRAFT_ID_MAPPINGS_SEGMENT);
-    }
-    const entries = await durableStoreOperation;
-    if (entries === undefined) {
-        return mappings;
-    }
-    const keys$1 = keys(entries);
-    for (const key of keys$1) {
-        const entry = entries[key].data;
-        if (isLegacyDraftIdMapping(key)) {
-            mappings.push({
-                draftKey: getRecordKeyForId(entry.draftId),
-                canonicalKey: getRecordKeyForId(entry.canonicalId),
-            });
-        }
-        else {
-            mappings.push(entry);
-        }
-    }
-    return mappings;
+const DraftIdMappingKeyPrefix240 = 'DraftIdMapping::';
+const DraftKeyMappingKeyPrefix = 'DraftKeyMapping::V2::';
+const DRAFT_ID_MAPPINGS_SEGMENT = 'DRAFT_ID_MAPPINGS';
+function isLegacyDraftIdMapping(key, data) {
+    return key.startsWith(DraftIdMappingKeyPrefix240);
+}
+// TODO [W-11677776]: in 242 we changed the format to store keys instead of ids
+// this can be removed when we drop support for id storing
+function getRecordKeyForId(id) {
+    return `UiApi::RecordRepresentation:${id}`;
+}
+function generateDraftIdMappingKey(draftIdMapping) {
+    return `${DraftKeyMappingKeyPrefix}${draftIdMapping.draftKey}::${draftIdMapping.canonicalKey}`;
+}
+/**
+ *
+ * @param mappingIds (optional) requested mapping ids, if undefined all will be retrieved
+ */
+async function getDraftIdMappings(durableStore, mappingIds) {
+    const mappings = [];
+    let durableStoreOperation;
+    if (mappingIds === undefined) {
+        durableStoreOperation =
+            durableStore.getAllEntries(DRAFT_ID_MAPPINGS_SEGMENT);
+    }
+    else {
+        durableStoreOperation = durableStore.getEntries(mappingIds, DRAFT_ID_MAPPINGS_SEGMENT);
+    }
+    const entries = await durableStoreOperation;
+    if (entries === undefined) {
+        return mappings;
+    }
+    const keys$1 = keys(entries);
+    for (const key of keys$1) {
+        const entry = entries[key].data;
+        if (isLegacyDraftIdMapping(key)) {
+            mappings.push({
+                draftKey: getRecordKeyForId(entry.draftId),
+                canonicalKey: getRecordKeyForId(entry.canonicalId),
+            });
+        }
+        else {
+            mappings.push(entry);
+        }
+    }
+    return mappings;
 }
 
-/**
- * Generates a time-ordered, unique id to associate with a DraftAction. Ensures
- * no collisions with existing draft action IDs.
- */
-function generateUniqueDraftActionId(existingIds) {
-    // new id in milliseconds with some extra digits for collisions
-    let newId = new Date().getTime() * 100;
-    const existingAsNumbers = existingIds
-        .map((id) => parseInt(id, 10))
-        .filter((parsed) => !isNaN(parsed));
-    let counter = 0;
-    while (existingAsNumbers.includes(newId)) {
-        newId += 1;
-        counter += 1;
-        // if the counter is 100+ then somehow this method has been called 100
-        // times in one millisecond
-        if (counter >= 100) {
-            // eslint-disable-next-line @salesforce/lds/no-error-in-production
-            throw new Error('Unable to generate unique new draft ID');
-        }
-    }
-    return newId.toString();
+/**
+ * Generates a time-ordered, unique id to associate with a DraftAction. Ensures
+ * no collisions with existing draft action IDs.
+ */
+function generateUniqueDraftActionId(existingIds) {
+    // new id in milliseconds with some extra digits for collisions
+    let newId = new Date().getTime() * 100;
+    const existingAsNumbers = existingIds
+        .map((id) => parseInt(id, 10))
+        .filter((parsed) => !isNaN(parsed));
+    let counter = 0;
+    while (existingAsNumbers.includes(newId)) {
+        newId += 1;
+        counter += 1;
+        // if the counter is 100+ then somehow this method has been called 100
+        // times in one millisecond
+        if (counter >= 100) {
+            // eslint-disable-next-line @salesforce/lds/no-error-in-production
+            throw new Error('Unable to generate unique new draft ID');
+        }
+    }
+    return newId.toString();
 }
 
-var CustomActionResultType;
-(function (CustomActionResultType) {
-    CustomActionResultType["SUCCESS"] = "SUCCESS";
-    CustomActionResultType["FAILURE"] = "FAILURE";
-})(CustomActionResultType || (CustomActionResultType = {}));
-var CustomActionErrorType;
-(function (CustomActionErrorType) {
-    CustomActionErrorType["NETWORK_ERROR"] = "NETWORK_ERROR";
-    CustomActionErrorType["CLIENT_ERROR"] = "CLIENT_ERROR";
-})(CustomActionErrorType || (CustomActionErrorType = {}));
-function isCustomActionSuccess(result) {
-    return result.type === CustomActionResultType.SUCCESS;
-}
-function isCustomActionFailed(result) {
-    return result.type === CustomActionResultType.FAILURE;
-}
-function customActionHandler(executor, id, draftQueue) {
-    const handle = (action, actionCompleted, actionErrored) => {
-        notifyCustomActionToExecute(action, actionCompleted, actionErrored);
-        return Promise.resolve(ProcessActionResult.CUSTOM_ACTION_WAITING);
-    };
-    const notifyCustomActionToExecute = (action, actionCompleted, actionErrored) => {
-        if (executor !== undefined) {
-            executor(action, executorCompleted(action, actionCompleted, actionErrored));
-        }
-    };
-    const executorCompleted = (action, actionCompleted, actionErrored) => (result) => {
-        if (isCustomActionSuccess(result)) {
-            actionCompleted({
-                ...action,
-                status: DraftActionStatus.Completed,
-                response: createOkResponse(undefined),
-            });
-        }
-        else if (isCustomActionFailed(result)) {
-            actionErrored({
-                ...action,
-                status: DraftActionStatus.Error,
-                error: result.error.message,
-            }, result.error.type === CustomActionErrorType.NETWORK_ERROR);
-        }
-    };
-    const buildPendingAction = (action, queue) => {
-        const { data, tag, targetId, handler } = action;
-        const id = generateUniqueDraftActionId(queue.map((a) => a.id));
-        return Promise.resolve({
-            id,
-            targetId,
-            status: DraftActionStatus.Pending,
-            data,
-            tag,
-            timestamp: Date.now(),
-            metadata: data,
-            handler,
-        });
-    };
-    const getQueueOperationsForCompletingDrafts = (_queue, action) => {
-        const { id } = action;
-        const queueOperations = [];
-        queueOperations.push({
-            type: QueueOperationType.Delete,
-            id: id,
-        });
-        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;
-    };
-    return {
-        handlerId: id,
-        enqueue: (data) => {
-            return draftQueue.enqueue(id, data);
-        },
-        handleAction: handle,
-        buildPendingAction,
-        getQueueOperationsForCompletingDrafts: getQueueOperationsForCompletingDrafts,
-        handleReplaceAction: replaceAction,
-        getRedirectMappings,
-        handleActionRemoved: () => Promise.resolve(),
-        handleActionCompleted: () => Promise.resolve(),
-        handleActionEnqueued: () => Promise.resolve(),
-        getDataForAction: () => Promise.resolve(undefined),
-        getDraftMetadata: () => {
-            throw Error('getDraftMetadata not supported for custom actions');
-        },
-        applyDraftsToIncomingData: () => {
-            throw Error('applyDraftsToIncomingData not supported for custom actions');
-        },
-        shouldDeleteActionByTagOnRemoval: () => false,
-        updateMetadata: (existing, incoming) => incoming,
-        canHandlePublish: () => false,
-        canRepresentationContainDraftMetadata: () => false,
-        mergeActions: () => {
-            throw Error('mergeActions not supported for custom actions');
-        },
-    };
+var CustomActionResultType;
+(function (CustomActionResultType) {
+    CustomActionResultType["SUCCESS"] = "SUCCESS";
+    CustomActionResultType["FAILURE"] = "FAILURE";
+})(CustomActionResultType || (CustomActionResultType = {}));
+var CustomActionErrorType;
+(function (CustomActionErrorType) {
+    CustomActionErrorType["NETWORK_ERROR"] = "NETWORK_ERROR";
+    CustomActionErrorType["CLIENT_ERROR"] = "CLIENT_ERROR";
+})(CustomActionErrorType || (CustomActionErrorType = {}));
+function isCustomActionSuccess(result) {
+    return result.type === CustomActionResultType.SUCCESS;
+}
+function isCustomActionFailed(result) {
+    return result.type === CustomActionResultType.FAILURE;
+}
+function customActionHandler(executor, id, draftQueue) {
+    const handle = (action, actionCompleted, actionErrored) => {
+        notifyCustomActionToExecute(action, actionCompleted, actionErrored);
+        return Promise.resolve(ProcessActionResult.CUSTOM_ACTION_WAITING);
+    };
+    const notifyCustomActionToExecute = (action, actionCompleted, actionErrored) => {
+        if (executor !== undefined) {
+            executor(action, executorCompleted(action, actionCompleted, actionErrored));
+        }
+    };
+    const executorCompleted = (action, actionCompleted, actionErrored) => (result) => {
+        if (isCustomActionSuccess(result)) {
+            actionCompleted({
+                ...action,
+                status: DraftActionStatus.Completed,
+                response: createOkResponse(undefined),
+            });
+        }
+        else if (isCustomActionFailed(result)) {
+            actionErrored({
+                ...action,
+                status: DraftActionStatus.Error,
+                error: result.error.message,
+            }, result.error.type === CustomActionErrorType.NETWORK_ERROR);
+        }
+    };
+    const buildPendingAction = (action, queue) => {
+        const { data, tag, targetId, handler } = action;
+        const id = generateUniqueDraftActionId(queue.map((a) => a.id));
+        return Promise.resolve({
+            id,
+            targetId,
+            status: DraftActionStatus.Pending,
+            data,
+            tag,
+            timestamp: Date.now(),
+            metadata: data,
+            handler,
+        });
+    };
+    const getQueueOperationsForCompletingDrafts = (_queue, action) => {
+        const { id } = action;
+        const queueOperations = [];
+        queueOperations.push({
+            type: QueueOperationType.Delete,
+            id: id,
+        });
+        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;
+    };
+    return {
+        handlerId: id,
+        enqueue: (data) => {
+            return draftQueue.enqueue(id, data);
+        },
+        handleAction: handle,
+        buildPendingAction,
+        getQueueOperationsForCompletingDrafts: getQueueOperationsForCompletingDrafts,
+        handleReplaceAction: replaceAction,
+        getRedirectMappings,
+        handleActionRemoved: () => Promise.resolve(),
+        handleActionCompleted: () => Promise.resolve(),
+        handleActionEnqueued: () => Promise.resolve(),
+        getDataForAction: () => Promise.resolve(undefined),
+        getDraftMetadata: () => {
+            throw Error('getDraftMetadata not supported for custom actions');
+        },
+        applyDraftsToIncomingData: () => {
+            throw Error('applyDraftsToIncomingData not supported for custom actions');
+        },
+        shouldDeleteActionByTagOnRemoval: () => false,
+        updateMetadata: (existing, incoming) => incoming,
+        canHandlePublish: () => false,
+        canRepresentationContainDraftMetadata: () => false,
+        mergeActions: () => {
+            throw Error('mergeActions not supported for custom actions');
+        },
+    };
 }
 
-const DRAFT_SEGMENT = 'DRAFT';
-class DurableDraftQueue {
-    getHandler(id) {
-        const handler = this.handlers[id];
-        if (handler === undefined) {
-            throw Error(`No handler registered for ${id}`);
-        }
-        return handler;
-    }
-    constructor(draftStore) {
-        this.retryIntervalMilliseconds = 0;
-        this.minimumRetryInterval = 250;
-        this.maximumRetryInterval = 32000;
-        this.draftQueueChangedListeners = [];
-        this.state = DraftQueueState.Stopped;
-        this.userState = DraftQueueState.Stopped;
-        this.uploadingActionId = undefined;
-        this.timeoutHandler = undefined;
-        this.handlers = {};
-        this.draftStore = draftStore;
-        this.workerPool = new AsyncWorkerPool(1);
-    }
-    addHandler(handler) {
-        const id = handler.handlerId;
-        if (this.handlers[id] !== undefined) {
-            return Promise.reject(`Unable to add handler to id: ${id} because it already exists.`);
-        }
-        this.handlers[id] = handler;
-        return Promise.resolve();
-    }
-    removeHandler(id) {
-        delete this.handlers[id];
-        return Promise.resolve();
-    }
-    addCustomHandler(id, executor) {
-        const handler = customActionHandler(executor, id, this);
-        return this.addHandler(handler);
-    }
-    getQueueState() {
-        return this.state;
-    }
-    async startQueue() {
-        this.userState = DraftQueueState.Started;
-        if (this.state === DraftQueueState.Started) {
-            // Do nothing if the queue state is already started
-            return Promise.resolve();
-        }
-        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();
-        }
-        this.retryIntervalMilliseconds = 0;
-        this.state = DraftQueueState.Started;
-        await this.notifyChangedListeners({
-            type: DraftQueueEventType.QueueStateChanged,
-            state: this.state,
-        });
-        const result = await this.processNextAction();
-        switch (result) {
-            case ProcessActionResult.BLOCKED_ON_ERROR:
-                this.state = DraftQueueState.Error;
-                return Promise.reject();
-            default:
-                return Promise.resolve();
-        }
-    }
-    stopQueue() {
-        this.userState = DraftQueueState.Stopped;
-        if (this.state === DraftQueueState.Stopped) {
-            // Do nothing if the queue state is already stopped
-            return Promise.resolve();
-        }
-        this.stopQueueManually();
-        return this.notifyChangedListeners({
-            type: DraftQueueEventType.QueueStateChanged,
-            state: DraftQueueState.Stopped,
-        });
-    }
-    /**
-     * Used to stop the queue within DraftQueue without user interaction
-     */
-    stopQueueManually() {
-        if (this.timeoutHandler) {
-            clearTimeout(this.timeoutHandler);
-            this.timeoutHandler = undefined;
-        }
-        this.state = DraftQueueState.Stopped;
-    }
-    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;
-            }
-            queue.push(draft);
-        });
-        return queue.sort((a, b) => {
-            const aTime = parseInt(a.id, 10);
-            const bTime = parseInt(b.id, 10);
-            // safety check
-            if (isNaN(aTime)) {
-                return 1;
-            }
-            if (isNaN(bTime)) {
-                return -1;
-            }
-            return aTime - bTime;
-        });
-    }
-    async enqueue(handlerId, data) {
-        return this.workerPool.push({
-            workFn: 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,
-                };
-            },
-        });
-    }
-    registerOnChangedListener(listener) {
-        this.draftQueueChangedListeners.push(listener);
-        return () => {
-            this.draftQueueChangedListeners = this.draftQueueChangedListeners.filter((l) => {
-                return l !== listener;
-            });
-            return Promise.resolve();
-        };
-    }
-    async actionCompleted(action) {
-        return this.workerPool.push({
-            workFn: 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,
-                });
-                if (this.state === DraftQueueState.Started) {
-                    this.processNextAction();
-                }
-            },
-        });
-    }
-    async actionFailed(action, retry) {
-        this.uploadingActionId = undefined;
-        if (retry && this.state !== DraftQueueState.Stopped) {
-            this.state = DraftQueueState.Waiting;
-            this.scheduleRetry();
-        }
-        else if (isDraftError(action)) {
-            return this.handleServerError(action, action.error);
-        }
-    }
-    handle(action) {
-        const handler = this.getHandler(action.handler);
-        if (handler === undefined) {
-            return Promise.reject(`No handler for ${action.handler}.`);
-        }
-        return handler.handleAction(action, this.actionCompleted.bind(this), this.actionFailed.bind(this));
-    }
-    async processNextAction() {
-        if (this.processingAction !== undefined) {
-            return this.processingAction;
-        }
-        const queue = await this.getQueueActions();
-        const action = queue[0];
-        if (action === undefined) {
-            this.processingAction = undefined;
-            return ProcessActionResult.NO_ACTION_TO_PROCESS;
-        }
-        const { status, id } = action;
-        if (status === DraftActionStatus.Error) {
-            this.state = DraftQueueState.Error;
-            this.processingAction = undefined;
-            return ProcessActionResult.BLOCKED_ON_ERROR;
-        }
-        if (id === this.uploadingActionId) {
-            this.state = DraftQueueState.Started;
-            this.processingAction = undefined;
-            return ProcessActionResult.ACTION_ALREADY_PROCESSING;
-        }
-        this.uploadingActionId = id;
-        this.processingAction = undefined;
-        if (this.state === DraftQueueState.Waiting) {
-            this.state = DraftQueueState.Started;
-        }
-        return this.handle(action);
-    }
-    async handleServerError(action, error) {
-        const queue = await this.getQueueActions();
-        const localAction = queue.filter((qAction) => qAction.id === action.id)[0];
-        let newMetadata = {};
-        if (localAction !== undefined) {
-            newMetadata = localAction.metadata || {};
-        }
-        const errorAction = {
-            ...action,
-            status: DraftActionStatus.Error,
-            error,
-            metadata: newMetadata,
-        };
-        await this.draftStore.writeAction(errorAction);
-        this.state = DraftQueueState.Error;
-        return this.notifyChangedListeners({
-            type: DraftQueueEventType.ActionFailed,
-            action: errorAction,
-        });
-    }
-    async notifyChangedListeners(event) {
-        const results = [];
-        const { draftQueueChangedListeners } = this;
-        const { length: draftQueueLen } = draftQueueChangedListeners;
-        for (let i = 0; i < draftQueueLen; i++) {
-            const listener = draftQueueChangedListeners[i];
-            results.push(listener(event));
-        }
-        await Promise.all(results);
-    }
-    /**
-     * only starts the queue if user state is "Started" and if queue not already
-     * started
-     */
-    async startQueueSafe() {
-        if (this.userState === DraftQueueState.Started && this.state !== DraftQueueState.Started) {
-            await this.startQueue();
-        }
-    }
-    async removeDraftAction(actionId) {
-        const queue = await this.getQueueActions();
-        //Get the store key for the removed action
-        const actions = queue.filter((action) => action.id === actionId);
-        if (actions.length === 0) {
-            // eslint-disable-next-line @salesforce/lds/no-error-in-production
-            throw new Error(`No removable action with id ${actionId}`);
-        }
-        const action = actions[0];
-        if (action.id === this.uploadingActionId) {
-            // eslint-disable-next-line @salesforce/lds/no-error-in-production
-            throw new Error(`Cannot remove an uploading draft action with ID ${actionId}`);
-        }
-        const handler = this.getHandler(action.handler);
-        const shouldDeleteRelated = handler.shouldDeleteActionByTagOnRemoval(action);
-        if (shouldDeleteRelated) {
-            await this.draftStore.deleteByTag(action.tag);
-        }
-        else {
-            await this.draftStore.deleteDraft(action.id);
-        }
-        await handler.handleActionRemoved(action, queue.filter((x) => x.id !== actionId));
-        await this.notifyChangedListeners({
-            type: DraftQueueEventType.ActionDeleted,
-            action,
-        });
-        if (this.userState === DraftQueueState.Started &&
-            this.state !== DraftQueueState.Started &&
-            this.replacingAction === undefined) {
-            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;
-    }
-    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;
-    }
-    async setMetadata(actionId, metadata) {
-        const keys$1 = keys(metadata);
-        const compatibleKeys = keys$1.filter((key) => {
-            const value = metadata[key];
-            return typeof key === 'string' && typeof value === 'string';
-        });
-        if (keys$1.length !== compatibleKeys.length) {
-            return Promise.reject('Cannot save incompatible metadata');
-        }
-        const queue = await this.getQueueActions();
-        const actions = queue.filter((action) => action.id === actionId);
-        if (actions.length === 0) {
-            return Promise.reject('cannot save metadata to non-existent action');
-        }
-        const action = actions[0];
-        const handler = this.getHandler(action.handler);
-        action.metadata = handler.updateMetadata(action.metadata, metadata);
-        await this.draftStore.writeAction(action);
-        await this.notifyChangedListeners({
-            type: DraftQueueEventType.ActionUpdated,
-            action: action,
-        });
-        return action;
-    }
-    scheduleRetry() {
-        const newInterval = this.retryIntervalMilliseconds * 2;
-        this.retryIntervalMilliseconds = Math.min(Math.max(newInterval, this.minimumRetryInterval), this.maximumRetryInterval);
-        this.timeoutHandler = setTimeout(() => {
-            if (this.state !== DraftQueueState.Stopped) {
-                this.processNextAction();
-            }
-        }, this.retryIntervalMilliseconds);
-    }
+const DRAFT_SEGMENT = 'DRAFT';
+class DurableDraftQueue {
+    getHandler(id) {
+        const handler = this.handlers[id];
+        if (handler === undefined) {
+            throw Error(`No handler registered for ${id}`);
+        }
+        return handler;
+    }
+    constructor(draftStore) {
+        this.retryIntervalMilliseconds = 0;
+        this.minimumRetryInterval = 250;
+        this.maximumRetryInterval = 32000;
+        this.draftQueueChangedListeners = [];
+        this.state = DraftQueueState.Stopped;
+        this.userState = DraftQueueState.Stopped;
+        this.uploadingActionId = undefined;
+        this.timeoutHandler = undefined;
+        this.handlers = {};
+        this.draftStore = draftStore;
+        this.workerPool = new AsyncWorkerPool(1);
+    }
+    addHandler(handler) {
+        const id = handler.handlerId;
+        if (this.handlers[id] !== undefined) {
+            return Promise.reject(`Unable to add handler to id: ${id} because it already exists.`);
+        }
+        this.handlers[id] = handler;
+        return Promise.resolve();
+    }
+    removeHandler(id) {
+        delete this.handlers[id];
+        return Promise.resolve();
+    }
+    addCustomHandler(id, executor) {
+        const handler = customActionHandler(executor, id, this);
+        return this.addHandler(handler);
+    }
+    getQueueState() {
+        return this.state;
+    }
+    async startQueue() {
+        this.userState = DraftQueueState.Started;
+        if (this.state === DraftQueueState.Started) {
+            // Do nothing if the queue state is already started
+            return Promise.resolve();
+        }
+        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();
+        }
+        this.retryIntervalMilliseconds = 0;
+        this.state = DraftQueueState.Started;
+        await this.notifyChangedListeners({
+            type: DraftQueueEventType.QueueStateChanged,
+            state: this.state,
+        });
+        const result = await this.processNextAction();
+        switch (result) {
+            case ProcessActionResult.BLOCKED_ON_ERROR:
+                this.state = DraftQueueState.Error;
+                return Promise.reject();
+            default:
+                return Promise.resolve();
+        }
+    }
+    stopQueue() {
+        this.userState = DraftQueueState.Stopped;
+        if (this.state === DraftQueueState.Stopped) {
+            // Do nothing if the queue state is already stopped
+            return Promise.resolve();
+        }
+        this.stopQueueManually();
+        return this.notifyChangedListeners({
+            type: DraftQueueEventType.QueueStateChanged,
+            state: DraftQueueState.Stopped,
+        });
+    }
+    /**
+     * Used to stop the queue within DraftQueue without user interaction
+     */
+    stopQueueManually() {
+        if (this.timeoutHandler) {
+            clearTimeout(this.timeoutHandler);
+            this.timeoutHandler = undefined;
+        }
+        this.state = DraftQueueState.Stopped;
+    }
+    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;
+            }
+            queue.push(draft);
+        });
+        return queue.sort((a, b) => {
+            const aTime = parseInt(a.id, 10);
+            const bTime = parseInt(b.id, 10);
+            // safety check
+            if (isNaN(aTime)) {
+                return 1;
+            }
+            if (isNaN(bTime)) {
+                return -1;
+            }
+            return aTime - bTime;
+        });
+    }
+    async enqueue(handlerId, data) {
+        return this.workerPool.push({
+            workFn: 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,
+                };
+            },
+        });
+    }
+    registerOnChangedListener(listener) {
+        this.draftQueueChangedListeners.push(listener);
+        return () => {
+            this.draftQueueChangedListeners = this.draftQueueChangedListeners.filter((l) => {
+                return l !== listener;
+            });
+            return Promise.resolve();
+        };
+    }
+    async actionCompleted(action) {
+        return this.workerPool.push({
+            workFn: 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,
+                });
+                if (this.state === DraftQueueState.Started) {
+                    this.processNextAction();
+                }
+            },
+        });
+    }
+    async actionFailed(action, retry) {
+        this.uploadingActionId = undefined;
+        if (retry && this.state !== DraftQueueState.Stopped) {
+            this.state = DraftQueueState.Waiting;
+            this.scheduleRetry();
+        }
+        else if (isDraftError(action)) {
+            return this.handleServerError(action, action.error);
+        }
+    }
+    handle(action) {
+        const handler = this.getHandler(action.handler);
+        if (handler === undefined) {
+            return Promise.reject(`No handler for ${action.handler}.`);
+        }
+        return handler.handleAction(action, this.actionCompleted.bind(this), this.actionFailed.bind(this));
+    }
+    async processNextAction() {
+        if (this.processingAction !== undefined) {
+            return this.processingAction;
+        }
+        const queue = await this.getQueueActions();
+        const action = queue[0];
+        if (action === undefined) {
+            this.processingAction = undefined;
+            return ProcessActionResult.NO_ACTION_TO_PROCESS;
+        }
+        const { status, id } = action;
+        if (status === DraftActionStatus.Error) {
+            this.state = DraftQueueState.Error;
+            this.processingAction = undefined;
+            return ProcessActionResult.BLOCKED_ON_ERROR;
+        }
+        if (id === this.uploadingActionId) {
+            this.state = DraftQueueState.Started;
+            this.processingAction = undefined;
+            return ProcessActionResult.ACTION_ALREADY_PROCESSING;
+        }
+        this.uploadingActionId = id;
+        this.processingAction = undefined;
+        if (this.state === DraftQueueState.Waiting) {
+            this.state = DraftQueueState.Started;
+        }
+        return this.handle(action);
+    }
+    async handleServerError(action, error) {
+        const queue = await this.getQueueActions();
+        const localAction = queue.filter((qAction) => qAction.id === action.id)[0];
+        let newMetadata = {};
+        if (localAction !== undefined) {
+            newMetadata = localAction.metadata || {};
+        }
+        const errorAction = {
+            ...action,
+            status: DraftActionStatus.Error,
+            error,
+            metadata: newMetadata,
+        };
+        await this.draftStore.writeAction(errorAction);
+        this.state = DraftQueueState.Error;
+        return this.notifyChangedListeners({
+            type: DraftQueueEventType.ActionFailed,
+            action: errorAction,
+        });
+    }
+    async notifyChangedListeners(event) {
+        const results = [];
+        const { draftQueueChangedListeners } = this;
+        const { length: draftQueueLen } = draftQueueChangedListeners;
+        for (let i = 0; i < draftQueueLen; i++) {
+            const listener = draftQueueChangedListeners[i];
+            results.push(listener(event));
+        }
+        await Promise.all(results);
+    }
+    /**
+     * only starts the queue if user state is "Started" and if queue not already
+     * started
+     */
+    async startQueueSafe() {
+        if (this.userState === DraftQueueState.Started && this.state !== DraftQueueState.Started) {
+            await this.startQueue();
+        }
+    }
+    async removeDraftAction(actionId) {
+        const queue = await this.getQueueActions();
+        //Get the store key for the removed action
+        const actions = queue.filter((action) => action.id === actionId);
+        if (actions.length === 0) {
+            // eslint-disable-next-line @salesforce/lds/no-error-in-production
+            throw new Error(`No removable action with id ${actionId}`);
+        }
+        const action = actions[0];
+        if (action.id === this.uploadingActionId) {
+            // eslint-disable-next-line @salesforce/lds/no-error-in-production
+            throw new Error(`Cannot remove an uploading draft action with ID ${actionId}`);
+        }
+        const handler = this.getHandler(action.handler);
+        const shouldDeleteRelated = handler.shouldDeleteActionByTagOnRemoval(action);
+        if (shouldDeleteRelated) {
+            await this.draftStore.deleteByTag(action.tag);
+        }
+        else {
+            await this.draftStore.deleteDraft(action.id);
+        }
+        await handler.handleActionRemoved(action, queue.filter((x) => x.id !== actionId));
+        await this.notifyChangedListeners({
+            type: DraftQueueEventType.ActionDeleted,
+            action,
+        });
+        if (this.userState === DraftQueueState.Started &&
+            this.state !== DraftQueueState.Started &&
+            this.replacingAction === undefined) {
+            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;
+    }
+    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;
+    }
+    async setMetadata(actionId, metadata) {
+        const keys$1 = keys(metadata);
+        const compatibleKeys = keys$1.filter((key) => {
+            const value = metadata[key];
+            return typeof key === 'string' && typeof value === 'string';
+        });
+        if (keys$1.length !== compatibleKeys.length) {
+            return Promise.reject('Cannot save incompatible metadata');
+        }
+        const queue = await this.getQueueActions();
+        const actions = queue.filter((action) => action.id === actionId);
+        if (actions.length === 0) {
+            return Promise.reject('cannot save metadata to non-existent action');
+        }
+        const action = actions[0];
+        const handler = this.getHandler(action.handler);
+        action.metadata = handler.updateMetadata(action.metadata, metadata);
+        await this.draftStore.writeAction(action);
+        await this.notifyChangedListeners({
+            type: DraftQueueEventType.ActionUpdated,
+            action: action,
+        });
+        return action;
+    }
+    scheduleRetry() {
+        const newInterval = this.retryIntervalMilliseconds * 2;
+        this.retryIntervalMilliseconds = Math.min(Math.max(newInterval, this.minimumRetryInterval), this.maximumRetryInterval);
+        this.timeoutHandler = setTimeout(() => {
+            if (this.state !== DraftQueueState.Stopped) {
+                this.processNextAction();
+            }
+        }, this.retryIntervalMilliseconds);
+    }
 }
 
-const DRAFT_ACTION_KEY_JUNCTION = '__DraftAction__';
-function buildDraftDurableStoreKey(recordKey, draftActionId) {
-    return `${recordKey}${DRAFT_ACTION_KEY_JUNCTION}${draftActionId}`;
-}
-/**
- * Implements a write-through InMemoryStore for Drafts, storing all drafts in a
- * in-memory store with a write through to the DurableStore.
- *
- * Before any reads or writes come in from the draft queue, we need to revive the draft
- * queue into memory. During this initial revive, any writes are queued up and operated on the
- * queue once it's in memory. Similarly any reads are delayed until the queue is in memory.
- *
- */
-class DurableDraftStore {
-    constructor(durableStore) {
-        this.draftStore = {};
-        // queue of writes that were made during the initial sync
-        this.writeQueue = [];
-        this.durableStore = durableStore;
-        this.resyncDraftStore();
-    }
-    writeAction(action) {
-        const addAction = () => {
-            const { id, tag } = action;
-            this.draftStore[id] = action;
-            const durableEntryKey = buildDraftDurableStoreKey(tag, id);
-            const entry = {
-                data: action,
-            };
-            const entries = { [durableEntryKey]: entry };
-            return this.durableStore.setEntries(entries, DRAFT_SEGMENT);
-        };
-        return this.enqueueAction(addAction);
-    }
-    getAllDrafts() {
-        const waitForOngoingSync = this.syncPromise || Promise.resolve();
-        return waitForOngoingSync.then(() => {
-            const { draftStore } = this;
-            const keys$1 = keys(draftStore);
-            const actionArray = [];
-            for (let i = 0, len = keys$1.length; i < len; i++) {
-                const key = keys$1[i];
-                actionArray.push(draftStore[key]);
-            }
-            return actionArray;
-        });
-    }
-    deleteDraft(id) {
-        const deleteAction = () => {
-            const draft = this.draftStore[id];
-            if (draft !== undefined) {
-                delete this.draftStore[id];
-                const durableKey = buildDraftDurableStoreKey(draft.tag, draft.id);
-                return this.durableStore.evictEntries([durableKey], DRAFT_SEGMENT);
-            }
-            return Promise.resolve();
-        };
-        return this.enqueueAction(deleteAction);
-    }
-    deleteByTag(tag) {
-        const deleteAction = () => {
-            const { draftStore } = this;
-            const keys$1 = keys(draftStore);
-            const durableKeys = [];
-            for (let i = 0, len = keys$1.length; i < len; i++) {
-                const key = keys$1[i];
-                const action = draftStore[key];
-                if (action.tag === tag) {
-                    delete draftStore[action.id];
-                    durableKeys.push(buildDraftDurableStoreKey(action.tag, action.id));
-                }
-            }
-            return this.durableStore.evictEntries(durableKeys, DRAFT_SEGMENT);
-        };
-        return this.enqueueAction(deleteAction);
-    }
-    completeAction(queueOperations, mappings) {
-        const action = () => {
-            const durableStoreOperations = [];
-            const { draftStore } = this;
-            for (let i = 0, len = queueOperations.length; i < len; i++) {
-                const operation = queueOperations[i];
-                if (operation.type === QueueOperationType.Delete) {
-                    const action = draftStore[operation.id];
-                    if (action !== undefined) {
-                        delete draftStore[operation.id];
-                        const key = buildDraftDurableStoreKey(action.tag, action.id);
-                        durableStoreOperations.push({
-                            ids: [key],
-                            type: 'evictEntries',
-                            segment: DRAFT_SEGMENT,
-                        });
-                    }
-                }
-                else {
-                    const { action } = operation;
-                    const key = buildDraftDurableStoreKey(action.tag, action.id);
-                    draftStore[action.id] = action;
-                    durableStoreOperations.push({
-                        type: 'setEntries',
-                        segment: DRAFT_SEGMENT,
-                        entries: {
-                            [key]: {
-                                data: operation.action,
-                            },
-                        },
-                    });
-                }
-            }
-            if (mappings !== undefined) {
-                const entries = {};
-                for (const mapping of mappings) {
-                    const mappingKey = generateDraftIdMappingKey(mapping);
-                    entries[mappingKey] = { data: mapping };
-                }
-                durableStoreOperations.push({
-                    entries,
-                    type: 'setEntries',
-                    segment: DRAFT_ID_MAPPINGS_SEGMENT,
-                });
-            }
-            return this.durableStore.batchOperations(durableStoreOperations);
-        };
-        return this.enqueueAction(action);
-    }
-    /**
-     * Runs a write operation against the draft store, if the initial
-     * revive is still in progress, the action gets enqueued to run once the
-     * initial revive is complete
-     * @param action
-     * @returns a promise that is resolved once the action has run
-     */
-    enqueueAction(action) {
-        const { syncPromise, writeQueue: pendingMerges } = this;
-        // if the initial sync is done and existing operations have been run, no need to queue, just run
-        if (syncPromise === undefined && pendingMerges.length === 0) {
-            return action();
-        }
-        const deferred = new Promise((resolve, reject) => {
-            this.writeQueue.push(() => {
-                return action()
-                    .then((x) => {
-                    resolve(x);
-                })
-                    .catch((err) => reject(err));
-            });
-        });
-        return deferred;
-    }
-    /**
-     * Revives the draft store from the durable store. Once the draft store is
-     * revived, executes any queued up draft store operations that came in while
-     * reviving
-     */
-    resyncDraftStore() {
-        const sync = () => {
-            this.syncPromise = this.durableStore
-                .getAllEntries(DRAFT_SEGMENT)
-                .then((durableEntries) => {
-                if (durableEntries === undefined) {
-                    this.draftStore = {};
-                    return this.runQueuedOperations();
-                }
-                const { draftStore } = this;
-                const keys$1 = keys(durableEntries);
-                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);
-                        }
-                    }
-                }
-                return this.runQueuedOperations();
-            })
-                .finally(() => {
-                this.syncPromise = undefined;
-            });
-            return this.syncPromise;
-        };
-        // if there's an ongoing sync populating the in memory store, wait for it to complete before re-syncing
-        const { syncPromise } = this;
-        if (syncPromise === undefined) {
-            return sync();
-        }
-        return syncPromise.then(() => {
-            return sync();
-        });
-    }
-    /**
-     * Runs the operations that were queued up while reviving the
-     * draft store from the durable store
-     */
-    runQueuedOperations() {
-        const { writeQueue } = this;
-        if (writeQueue.length > 0) {
-            const queueItem = writeQueue.shift();
-            if (queueItem !== undefined) {
-                return queueItem().then(() => {
-                    return this.runQueuedOperations();
-                });
-            }
-        }
-        return Promise.resolve();
-    }
+const DRAFT_ACTION_KEY_JUNCTION = '__DraftAction__';
+function buildDraftDurableStoreKey(recordKey, draftActionId) {
+    return `${recordKey}${DRAFT_ACTION_KEY_JUNCTION}${draftActionId}`;
+}
+/**
+ * Implements a write-through InMemoryStore for Drafts, storing all drafts in a
+ * in-memory store with a write through to the DurableStore.
+ *
+ * Before any reads or writes come in from the draft queue, we need to revive the draft
+ * queue into memory. During this initial revive, any writes are queued up and operated on the
+ * queue once it's in memory. Similarly any reads are delayed until the queue is in memory.
+ *
+ */
+class DurableDraftStore {
+    constructor(durableStore) {
+        this.draftStore = {};
+        // queue of writes that were made during the initial sync
+        this.writeQueue = [];
+        this.durableStore = durableStore;
+        this.resyncDraftStore();
+    }
+    writeAction(action) {
+        const addAction = () => {
+            const { id, tag } = action;
+            this.draftStore[id] = action;
+            const durableEntryKey = buildDraftDurableStoreKey(tag, id);
+            const entry = {
+                data: action,
+            };
+            const entries = { [durableEntryKey]: entry };
+            return this.durableStore.setEntries(entries, DRAFT_SEGMENT);
+        };
+        return this.enqueueAction(addAction);
+    }
+    getAllDrafts() {
+        const waitForOngoingSync = this.syncPromise || Promise.resolve();
+        return waitForOngoingSync.then(() => {
+            const { draftStore } = this;
+            const keys$1 = keys(draftStore);
+            const actionArray = [];
+            for (let i = 0, len = keys$1.length; i < len; i++) {
+                const key = keys$1[i];
+                actionArray.push(draftStore[key]);
+            }
+            return actionArray;
+        });
+    }
+    deleteDraft(id) {
+        const deleteAction = () => {
+            const draft = this.draftStore[id];
+            if (draft !== undefined) {
+                delete this.draftStore[id];
+                const durableKey = buildDraftDurableStoreKey(draft.tag, draft.id);
+                return this.durableStore.evictEntries([durableKey], DRAFT_SEGMENT);
+            }
+            return Promise.resolve();
+        };
+        return this.enqueueAction(deleteAction);
+    }
+    deleteByTag(tag) {
+        const deleteAction = () => {
+            const { draftStore } = this;
+            const keys$1 = keys(draftStore);
+            const durableKeys = [];
+            for (let i = 0, len = keys$1.length; i < len; i++) {
+                const key = keys$1[i];
+                const action = draftStore[key];
+                if (action.tag === tag) {
+                    delete draftStore[action.id];
+                    durableKeys.push(buildDraftDurableStoreKey(action.tag, action.id));
+                }
+            }
+            return this.durableStore.evictEntries(durableKeys, DRAFT_SEGMENT);
+        };
+        return this.enqueueAction(deleteAction);
+    }
+    completeAction(queueOperations, mappings) {
+        const action = () => {
+            const durableStoreOperations = [];
+            const { draftStore } = this;
+            for (let i = 0, len = queueOperations.length; i < len; i++) {
+                const operation = queueOperations[i];
+                if (operation.type === QueueOperationType.Delete) {
+                    const action = draftStore[operation.id];
+                    if (action !== undefined) {
+                        delete draftStore[operation.id];
+                        const key = buildDraftDurableStoreKey(action.tag, action.id);
+                        durableStoreOperations.push({
+                            ids: [key],
+                            type: 'evictEntries',
+                            segment: DRAFT_SEGMENT,
+                        });
+                    }
+                }
+                else {
+                    const { action } = operation;
+                    const key = buildDraftDurableStoreKey(action.tag, action.id);
+                    draftStore[action.id] = action;
+                    durableStoreOperations.push({
+                        type: 'setEntries',
+                        segment: DRAFT_SEGMENT,
+                        entries: {
+                            [key]: {
+                                data: operation.action,
+                            },
+                        },
+                    });
+                }
+            }
+            if (mappings !== undefined) {
+                const entries = {};
+                for (const mapping of mappings) {
+                    const mappingKey = generateDraftIdMappingKey(mapping);
+                    entries[mappingKey] = { data: mapping };
+                }
+                durableStoreOperations.push({
+                    entries,
+                    type: 'setEntries',
+                    segment: DRAFT_ID_MAPPINGS_SEGMENT,
+                });
+            }
+            return this.durableStore.batchOperations(durableStoreOperations);
+        };
+        return this.enqueueAction(action);
+    }
+    /**
+     * Runs a write operation against the draft store, if the initial
+     * revive is still in progress, the action gets enqueued to run once the
+     * initial revive is complete
+     * @param action
+     * @returns a promise that is resolved once the action has run
+     */
+    enqueueAction(action) {
+        const { syncPromise, writeQueue: pendingMerges } = this;
+        // if the initial sync is done and existing operations have been run, no need to queue, just run
+        if (syncPromise === undefined && pendingMerges.length === 0) {
+            return action();
+        }
+        const deferred = new Promise((resolve, reject) => {
+            this.writeQueue.push(() => {
+                return action()
+                    .then((x) => {
+                    resolve(x);
+                })
+                    .catch((err) => reject(err));
+            });
+        });
+        return deferred;
+    }
+    /**
+     * Revives the draft store from the durable store. Once the draft store is
+     * revived, executes any queued up draft store operations that came in while
+     * reviving
+     */
+    resyncDraftStore() {
+        const sync = () => {
+            this.syncPromise = this.durableStore
+                .getAllEntries(DRAFT_SEGMENT)
+                .then((durableEntries) => {
+                if (durableEntries === undefined) {
+                    this.draftStore = {};
+                    return this.runQueuedOperations();
+                }
+                const { draftStore } = this;
+                const keys$1 = keys(durableEntries);
+                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);
+                        }
+                    }
+                }
+                return this.runQueuedOperations();
+            })
+                .finally(() => {
+                this.syncPromise = undefined;
+            });
+            return this.syncPromise;
+        };
+        // if there's an ongoing sync populating the in memory store, wait for it to complete before re-syncing
+        const { syncPromise } = this;
+        if (syncPromise === undefined) {
+            return sync();
+        }
+        return syncPromise.then(() => {
+            return sync();
+        });
+    }
+    /**
+     * Runs the operations that were queued up while reviving the
+     * draft store from the durable store
+     */
+    runQueuedOperations() {
+        const { writeQueue } = this;
+        if (writeQueue.length > 0) {
+            const queueItem = writeQueue.shift();
+            if (queueItem !== undefined) {
+                return queueItem().then(() => {
+                    return this.runQueuedOperations();
+                });
+            }
+        }
+        return Promise.resolve();
+    }
 }
 
-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 = {};
-    }
-    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;
-            }
-            await actionErrored({
-                ...action,
-                error: response,
-                status: DraftActionStatus.Error,
-            }, false);
-            return ProcessActionResult.ACTION_ERRORED;
-        }
-        catch (_a) {
-            await actionErrored(action, true);
-            return ProcessActionResult.NETWORK_ERROR;
-        }
-    }
-    async buildPendingAction(request, queue) {
-        const targetId = await this.getIdFromRequest(request);
-        if (targetId === undefined) {
-            return Promise.reject(new Error('Cannot determine target id from the resource 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) {
-        const { method } = action.data;
-        // delete adapters don't get a value back to ingest so
-        // we ingest it for them here
-        if (method === 'delete') {
-            await this.reingestRecord(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, _queue, 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(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');
-        }
-        //reject if the action to replace is a POST action
-        const pendingAction = actionToReplace;
-        if (pendingAction.data.method === 'post') {
-            // eslint-disable-next-line @salesforce/lds/no-error-in-production
-            throw new 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,
-            };
-        }
-        else {
-            // eslint-disable-next-line @salesforce/lds/no-error-in-production
-            throw new Error('Incompatible Action types to replace one another');
-        }
-    }
-    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];
-    }
-    async ingestResponses(responses, action) {
-        const luvio = this.getLuvio();
-        await luvio.handleSuccessResponse(() => {
-            for (const entry of responses) {
-                const { response, synchronousIngest } = entry;
-                synchronousIngest(response, action);
-            }
-            // must call base broadcast
-            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);
+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 = {};
+    }
+    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;
+            }
+            await actionErrored({
+                ...action,
+                error: response,
+                status: DraftActionStatus.Error,
+            }, false);
+            return ProcessActionResult.ACTION_ERRORED;
+        }
+        catch (_a) {
+            await actionErrored(action, true);
+            return ProcessActionResult.NETWORK_ERROR;
+        }
+    }
+    async buildPendingAction(request, queue) {
+        const targetId = await this.getIdFromRequest(request);
+        if (targetId === undefined) {
+            return Promise.reject(new Error('Cannot determine target id from the resource 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) {
+        const { method } = action.data;
+        // delete adapters don't get a value back to ingest so
+        // we ingest it for them here
+        if (method === 'delete') {
+            await this.reingestRecord(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, _queue, 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(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');
+        }
+        //reject if the action to replace is a POST action
+        const pendingAction = actionToReplace;
+        if (pendingAction.data.method === 'post') {
+            // eslint-disable-next-line @salesforce/lds/no-error-in-production
+            throw new 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,
+            };
+        }
+        else {
+            // eslint-disable-next-line @salesforce/lds/no-error-in-production
+            throw new Error('Incompatible Action types to replace one another');
+        }
+    }
+    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];
+    }
+    async ingestResponses(responses, action) {
+        const luvio = this.getLuvio();
+        await luvio.handleSuccessResponse(() => {
+            for (const entry of responses) {
+                const { response, synchronousIngest } = entry;
+                synchronousIngest(response, action);
+            }
+            // must call base broadcast
+            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.
- */
-var DraftActionOperationType;
-(function (DraftActionOperationType) {
-    DraftActionOperationType["Create"] = "create";
-    DraftActionOperationType["Update"] = "update";
-    DraftActionOperationType["Delete"] = "delete";
-    DraftActionOperationType["Custom"] = "custom";
-})(DraftActionOperationType || (DraftActionOperationType = {}));
-var DraftQueueOperationType;
-(function (DraftQueueOperationType) {
-    DraftQueueOperationType["ItemAdded"] = "added";
-    DraftQueueOperationType["ItemDeleted"] = "deleted";
-    DraftQueueOperationType["ItemCompleted"] = "completed";
-    DraftQueueOperationType["ItemFailed"] = "failed";
-    DraftQueueOperationType["ItemUpdated"] = "updated";
-    DraftQueueOperationType["QueueStarted"] = "started";
-    DraftQueueOperationType["QueueStopped"] = "stopped";
-})(DraftQueueOperationType || (DraftQueueOperationType = {}));
-/**
- * Converts the internal DraftAction's ResourceRequest into
- * a DraftActionOperationType.
- * Returns a DraftActionOperationType as long as the http request is a
- * valid method type for DraftQueue or else it is undefined.
- * @param action
- */
-function getOperationTypeFrom(action) {
-    if (isResourceRequestAction(action)) {
-        if (action.data !== undefined && action.data.method !== undefined) {
-            switch (action.data.method) {
-                case 'put':
-                case 'patch':
-                    return DraftActionOperationType.Update;
-                case 'post':
-                    return DraftActionOperationType.Create;
-                case 'delete':
-                    return DraftActionOperationType.Delete;
-                default:
-                    // eslint-disable-next-line @salesforce/lds/no-error-in-production
-                    throw new Error(`${action.data.method} is an unsupported request method type for DraftQueue.`);
-            }
-        }
-        else {
-            // eslint-disable-next-line @salesforce/lds/no-error-in-production
-            throw new Error(`action has no data found`);
-        }
-    }
-    else {
-        return DraftActionOperationType.Custom;
-    }
-}
-function toQueueState(queue) {
-    return (states) => {
-        return {
-            queueState: queue.getQueueState(),
-            items: states,
-        };
-    };
-}
-class DraftManager {
-    constructor(draftQueue) {
-        this.listeners = [];
-        this.draftQueue = draftQueue;
-        draftQueue.registerOnChangedListener((event) => {
-            if (this.shouldEmitDraftEvent(event)) {
-                return this.callListeners(event);
-            }
-            return Promise.resolve();
-        });
-    }
-    shouldEmitDraftEvent(event) {
-        const { type } = event;
-        return [
-            DraftQueueEventType.ActionAdded,
-            DraftQueueEventType.ActionCompleted,
-            DraftQueueEventType.ActionDeleted,
-            DraftQueueEventType.ActionFailed,
-            DraftQueueEventType.ActionUpdated,
-            DraftQueueEventType.QueueStateChanged,
-        ].includes(type);
-    }
-    draftQueueEventTypeToOperationType(type) {
-        switch (type) {
-            case DraftQueueEventType.ActionAdded:
-                return DraftQueueOperationType.ItemAdded;
-            case DraftQueueEventType.ActionCompleted:
-                return DraftQueueOperationType.ItemCompleted;
-            case DraftQueueEventType.ActionDeleted:
-                return DraftQueueOperationType.ItemDeleted;
-            case DraftQueueEventType.ActionFailed:
-                return DraftQueueOperationType.ItemFailed;
-            case DraftQueueEventType.ActionUpdated:
-                return DraftQueueOperationType.ItemUpdated;
-            default:
-                throw Error('Unsupported event type');
-        }
-    }
-    draftQueueStateToOperationType(state) {
-        switch (state) {
-            case DraftQueueState.Started:
-                return DraftQueueOperationType.QueueStarted;
-            case DraftQueueState.Stopped:
-                return DraftQueueOperationType.QueueStopped;
-            default:
-                throw Error('Unsupported event type');
-        }
-    }
-    /**
-     * Enqueue a custom action on the DraftQueue for a handler
-     * @param handler the handler's id
-     * @param targetId
-     * @param tag - the key to group with in durable store
-     * @param metadata
-     * @returns
-     */
-    addCustomAction(handler, targetId, tag, metadata) {
-        return this.draftQueue
-            .enqueue(handler, {
-            data: metadata,
-            handler,
-            targetId,
-            tag,
-        })
-            .then((result) => {
-            return this.buildDraftQueueItem(result.action);
-        });
-    }
-    /**
-     * Get the current state of each of the DraftActions in the DraftQueue
-     * @returns A promise of an array of the state of each item in the DraftQueue
-     */
-    getQueue() {
-        return this.draftQueue
-            .getQueueActions()
-            .then((queueActions) => {
-            return queueActions.map(this.buildDraftQueueItem);
-        })
-            .then(toQueueState(this.draftQueue));
-    }
-    /**
-     * Starts the draft queue and begins processing the first item in the queue.
-     */
-    startQueue() {
-        return this.draftQueue.startQueue();
-    }
-    /**
-     * Stops the draft queue from processing more draft items after any current
-     * in progress items are finished.
-     */
-    stopQueue() {
-        return this.draftQueue.stopQueue();
-    }
-    /**
-     * Subscribes the listener to changes to the draft queue.
-     *
-     * Returns a closure to invoke in order to unsubscribe the listener
-     * from changes to the draft queue.
-     *
-     * @param listener The listener closure to subscribe to changes
-     */
-    registerDraftQueueChangedListener(listener) {
-        this.listeners.push(listener);
-        return () => {
-            this.listeners = this.listeners.filter((l) => {
-                return l !== listener;
-            });
-            return Promise.resolve();
-        };
-    }
-    /**
-     * Creates a custom action handler for the given handler
-     * @param handlerId
-     * @param executor
-     * @returns
-     */
-    setCustomActionExecutor(handlerId, executor) {
-        return this.draftQueue
-            .addCustomHandler(handlerId, (action, completed) => {
-            executor(this.buildDraftQueueItem(action), completed);
-        })
-            .then(() => {
-            return () => {
-                this.draftQueue.removeHandler(handlerId);
-                return Promise.resolve();
-            };
-        });
-    }
-    buildDraftQueueItem(action) {
-        const operationType = getOperationTypeFrom(action);
-        const { id, status, timestamp, targetId, metadata } = action;
-        const item = {
-            id,
-            targetId,
-            state: status,
-            timestamp,
-            operationType,
-            metadata,
-        };
-        if (isDraftError(action)) {
-            // We should always return an array, if the body is just a dictionary,
-            // stick it in an array
-            const body = isArray(action.error.body) ? action.error.body : [action.error.body];
-            const bodyString = stringify(body);
-            item.error = {
-                status: action.error.status || 0,
-                ok: action.error.ok || false,
-                headers: action.error.headers || {},
-                statusText: action.error.statusText || '',
-                bodyString,
-            };
-        }
-        return item;
-    }
-    async callListeners(event) {
-        if (this.listeners.length < 1) {
-            return;
-        }
-        const managerState = await this.getQueue();
-        let operationType, item;
-        if (isDraftQueueStateChangeEvent(event)) {
-            operationType = this.draftQueueStateToOperationType(event.state);
-        }
-        else {
-            const { action, type } = event;
-            item = this.buildDraftQueueItem(action);
-            operationType = this.draftQueueEventTypeToOperationType(type);
-        }
-        for (let i = 0, len = this.listeners.length; i < len; i++) {
-            const listener = this.listeners[i];
-            listener(managerState, operationType, item);
-        }
-    }
-    /**
-     * Removes the draft action identified by actionId from the draft queue.
-     *
-     * @param actionId The action identifier
-     *
-     * @returns The current state of the draft queue
-     */
-    removeDraftAction(actionId) {
-        return this.draftQueue.removeDraftAction(actionId).then(() => this.getQueue());
-    }
-    /**
-     * Replaces the resource request of `withAction` for the resource request
-     * 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
-     */
-    replaceAction(actionId, withActionId) {
-        return this.draftQueue.replaceAction(actionId, withActionId).then((replaced) => {
-            return this.buildDraftQueueItem(replaced);
-        });
-    }
-    /**
-     * 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.
-     * Action ids cannot be equal. Both actions must be acting on the same target
-     * object, and neither can currently be in progress.
-     *
-     * @param targetActionId The draft action id of the target action. This action
-     * will be replaced with the merged result.
-     * @param sourceActionId The draft action id to merge onto the target. This
-     * action will be removed after the merge.
-     */
-    mergeActions(targetActionId, sourceActionId) {
-        return this.draftQueue.mergeActions(targetActionId, sourceActionId).then((merged) => {
-            return this.buildDraftQueueItem(merged);
-        });
-    }
-    /**
-     * Sets the metadata object of the specified action to the
-     * provided metadata
-     * @param actionId The id of the action to set the metadata on
-     * @param metadata The metadata to set on the specified action
-     */
-    setMetadata(actionId, metadata) {
-        return this.draftQueue.setMetadata(actionId, metadata).then((updatedAction) => {
-            return this.buildDraftQueueItem(updatedAction);
-        });
-    }
+/**
+ * Denotes what kind of operation a DraftQueueItem represents.
+ */
+var DraftActionOperationType;
+(function (DraftActionOperationType) {
+    DraftActionOperationType["Create"] = "create";
+    DraftActionOperationType["Update"] = "update";
+    DraftActionOperationType["Delete"] = "delete";
+    DraftActionOperationType["Custom"] = "custom";
+})(DraftActionOperationType || (DraftActionOperationType = {}));
+var DraftQueueOperationType;
+(function (DraftQueueOperationType) {
+    DraftQueueOperationType["ItemAdded"] = "added";
+    DraftQueueOperationType["ItemDeleted"] = "deleted";
+    DraftQueueOperationType["ItemCompleted"] = "completed";
+    DraftQueueOperationType["ItemFailed"] = "failed";
+    DraftQueueOperationType["ItemUpdated"] = "updated";
+    DraftQueueOperationType["QueueStarted"] = "started";
+    DraftQueueOperationType["QueueStopped"] = "stopped";
+})(DraftQueueOperationType || (DraftQueueOperationType = {}));
+/**
+ * Converts the internal DraftAction's ResourceRequest into
+ * a DraftActionOperationType.
+ * Returns a DraftActionOperationType as long as the http request is a
+ * valid method type for DraftQueue or else it is undefined.
+ * @param action
+ */
+function getOperationTypeFrom(action) {
+    if (isResourceRequestAction(action)) {
+        if (action.data !== undefined && action.data.method !== undefined) {
+            switch (action.data.method) {
+                case 'put':
+                case 'patch':
+                    return DraftActionOperationType.Update;
+                case 'post':
+                    return DraftActionOperationType.Create;
+                case 'delete':
+                    return DraftActionOperationType.Delete;
+                default:
+                    // eslint-disable-next-line @salesforce/lds/no-error-in-production
+                    throw new Error(`${action.data.method} is an unsupported request method type for DraftQueue.`);
+            }
+        }
+        else {
+            // eslint-disable-next-line @salesforce/lds/no-error-in-production
+            throw new Error(`action has no data found`);
+        }
+    }
+    else {
+        return DraftActionOperationType.Custom;
+    }
+}
+function toQueueState(queue) {
+    return (states) => {
+        return {
+            queueState: queue.getQueueState(),
+            items: states,
+        };
+    };
+}
+class DraftManager {
+    constructor(draftQueue) {
+        this.listeners = [];
+        this.draftQueue = draftQueue;
+        draftQueue.registerOnChangedListener((event) => {
+            if (this.shouldEmitDraftEvent(event)) {
+                return this.callListeners(event);
+            }
+            return Promise.resolve();
+        });
+    }
+    shouldEmitDraftEvent(event) {
+        const { type } = event;
+        return [
+            DraftQueueEventType.ActionAdded,
+            DraftQueueEventType.ActionCompleted,
+            DraftQueueEventType.ActionDeleted,
+            DraftQueueEventType.ActionFailed,
+            DraftQueueEventType.ActionUpdated,
+            DraftQueueEventType.QueueStateChanged,
+        ].includes(type);
+    }
+    draftQueueEventTypeToOperationType(type) {
+        switch (type) {
+            case DraftQueueEventType.ActionAdded:
+                return DraftQueueOperationType.ItemAdded;
+            case DraftQueueEventType.ActionCompleted:
+                return DraftQueueOperationType.ItemCompleted;
+            case DraftQueueEventType.ActionDeleted:
+                return DraftQueueOperationType.ItemDeleted;
+            case DraftQueueEventType.ActionFailed:
+                return DraftQueueOperationType.ItemFailed;
+            case DraftQueueEventType.ActionUpdated:
+                return DraftQueueOperationType.ItemUpdated;
+            default:
+                throw Error('Unsupported event type');
+        }
+    }
+    draftQueueStateToOperationType(state) {
+        switch (state) {
+            case DraftQueueState.Started:
+                return DraftQueueOperationType.QueueStarted;
+            case DraftQueueState.Stopped:
+                return DraftQueueOperationType.QueueStopped;
+            default:
+                throw Error('Unsupported event type');
+        }
+    }
+    /**
+     * Enqueue a custom action on the DraftQueue for a handler
+     * @param handler the handler's id
+     * @param targetId
+     * @param tag - the key to group with in durable store
+     * @param metadata
+     * @returns
+     */
+    addCustomAction(handler, targetId, tag, metadata) {
+        return this.draftQueue
+            .enqueue(handler, {
+            data: metadata,
+            handler,
+            targetId,
+            tag,
+        })
+            .then((result) => {
+            return this.buildDraftQueueItem(result.action);
+        });
+    }
+    /**
+     * Get the current state of each of the DraftActions in the DraftQueue
+     * @returns A promise of an array of the state of each item in the DraftQueue
+     */
+    getQueue() {
+        return this.draftQueue
+            .getQueueActions()
+            .then((queueActions) => {
+            return queueActions.map(this.buildDraftQueueItem);
+        })
+            .then(toQueueState(this.draftQueue));
+    }
+    /**
+     * Starts the draft queue and begins processing the first item in the queue.
+     */
+    startQueue() {
+        return this.draftQueue.startQueue();
+    }
+    /**
+     * Stops the draft queue from processing more draft items after any current
+     * in progress items are finished.
+     */
+    stopQueue() {
+        return this.draftQueue.stopQueue();
+    }
+    /**
+     * Subscribes the listener to changes to the draft queue.
+     *
+     * Returns a closure to invoke in order to unsubscribe the listener
+     * from changes to the draft queue.
+     *
+     * @param listener The listener closure to subscribe to changes
+     */
+    registerDraftQueueChangedListener(listener) {
+        this.listeners.push(listener);
+        return () => {
+            this.listeners = this.listeners.filter((l) => {
+                return l !== listener;
+            });
+            return Promise.resolve();
+        };
+    }
+    /**
+     * Creates a custom action handler for the given handler
+     * @param handlerId
+     * @param executor
+     * @returns
+     */
+    setCustomActionExecutor(handlerId, executor) {
+        return this.draftQueue
+            .addCustomHandler(handlerId, (action, completed) => {
+            executor(this.buildDraftQueueItem(action), completed);
+        })
+            .then(() => {
+            return () => {
+                this.draftQueue.removeHandler(handlerId);
+                return Promise.resolve();
+            };
+        });
+    }
+    buildDraftQueueItem(action) {
+        const operationType = getOperationTypeFrom(action);
+        const { id, status, timestamp, targetId, metadata } = action;
+        const item = {
+            id,
+            targetId,
+            state: status,
+            timestamp,
+            operationType,
+            metadata,
+        };
+        if (isDraftError(action)) {
+            // We should always return an array, if the body is just a dictionary,
+            // stick it in an array
+            const body = isArray(action.error.body) ? action.error.body : [action.error.body];
+            const bodyString = stringify(body);
+            item.error = {
+                status: action.error.status || 0,
+                ok: action.error.ok || false,
+                headers: action.error.headers || {},
+                statusText: action.error.statusText || '',
+                bodyString,
+            };
+        }
+        return item;
+    }
+    async callListeners(event) {
+        if (this.listeners.length < 1) {
+            return;
+        }
+        const managerState = await this.getQueue();
+        let operationType, item;
+        if (isDraftQueueStateChangeEvent(event)) {
+            operationType = this.draftQueueStateToOperationType(event.state);
+        }
+        else {
+            const { action, type } = event;
+            item = this.buildDraftQueueItem(action);
+            operationType = this.draftQueueEventTypeToOperationType(type);
+        }
+        for (let i = 0, len = this.listeners.length; i < len; i++) {
+            const listener = this.listeners[i];
+            listener(managerState, operationType, item);
+        }
+    }
+    /**
+     * Removes the draft action identified by actionId from the draft queue.
+     *
+     * @param actionId The action identifier
+     *
+     * @returns The current state of the draft queue
+     */
+    removeDraftAction(actionId) {
+        return this.draftQueue.removeDraftAction(actionId).then(() => this.getQueue());
+    }
+    /**
+     * Replaces the resource request of `withAction` for the resource request
+     * 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
+     */
+    replaceAction(actionId, withActionId) {
+        return this.draftQueue.replaceAction(actionId, withActionId).then((replaced) => {
+            return this.buildDraftQueueItem(replaced);
+        });
+    }
+    /**
+     * 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.
+     * Action ids cannot be equal. Both actions must be acting on the same target
+     * object, and neither can currently be in progress.
+     *
+     * @param targetActionId The draft action id of the target action. This action
+     * will be replaced with the merged result.
+     * @param sourceActionId The draft action id to merge onto the target. This
+     * action will be removed after the merge.
+     */
+    mergeActions(targetActionId, sourceActionId) {
+        return this.draftQueue.mergeActions(targetActionId, sourceActionId).then((merged) => {
+            return this.buildDraftQueueItem(merged);
+        });
+    }
+    /**
+     * Sets the metadata object of the specified action to the
+     * provided metadata
+     * @param actionId The id of the action to set the metadata on
+     * @param metadata The metadata to set on the specified action
+     */
+    setMetadata(actionId, metadata) {
+        return this.draftQueue.setMetadata(actionId, metadata).then((updatedAction) => {
+            return this.buildDraftQueueItem(updatedAction);
+        });
+    }
 }
 
-function makeEnvironmentDraftAware(luvio, env, durableStore, handlers, draftQueue) {
-    const draftMetadata = {};
-    // setup existing store redirects when bootstrapping the environment
-    (async () => {
-        const mappings = await getDraftIdMappings(durableStore);
-        mappings.forEach((mapping) => {
-            const { draftKey, canonicalKey } = mapping;
-            env.storeRedirect(draftKey, canonicalKey);
-        });
-    })();
-    durableStore.registerOnChangedListener(async (changes) => {
-        const draftIdMappingsIds = [];
-        for (let i = 0, len = changes.length; i < len; i++) {
-            const change = changes[i];
-            if (change.segment === DRAFT_ID_MAPPINGS_SEGMENT) {
-                draftIdMappingsIds.push(...change.ids);
-            }
-        }
-        if (draftIdMappingsIds.length > 0) {
-            const mappings = await getDraftIdMappings(durableStore, draftIdMappingsIds);
-            mappings.forEach((mapping) => {
-                const { draftKey, canonicalKey } = mapping;
-                env.storeRedirect(draftKey, canonicalKey);
-            });
-        }
-    });
-    const handleSuccessResponse = async function (ingestAndBroadcastFunc, getResponseCacheKeysFunc) {
-        const queue = await draftQueue.getQueueActions();
-        if (queue.length === 0) {
-            return env.handleSuccessResponse(ingestAndBroadcastFunc, getResponseCacheKeysFunc);
-        }
-        const cacheKeySet = getResponseCacheKeysFunc();
-        for (const possibleKey of cacheKeySet.keys()) {
-            const key = typeof possibleKey === 'string' ? possibleKey : '';
-            const cacheKey = cacheKeySet.get(key);
-            for (const handler of handlers) {
-                if (cacheKey !== undefined &&
-                    handler.canRepresentationContainDraftMetadata(cacheKey.representationName)) {
-                    const metadata = await handler.getDraftMetadata(key);
-                    if (metadata !== undefined) {
-                        // if this key is related to a draft then mark it mergeable so
-                        // base environment revives it to staging store before ingestion
-                        cacheKey.mergeable = true;
-                        const existing = draftMetadata[key];
-                        if (existing === undefined) {
-                            draftMetadata[key] = { metadata, refCount: 1 };
-                        }
-                        else {
-                            draftMetadata[key] = { metadata, refCount: existing.refCount + 1 };
-                        }
-                    }
-                    break;
-                }
-            }
-        }
-        return env.handleSuccessResponse(ingestAndBroadcastFunc, () => cacheKeySet);
-    };
-    const storePublish = function (key, data) {
-        const draftMetadataForKey = draftMetadata[key];
-        for (const handler of handlers) {
-            if (handler.canHandlePublish(key)) {
-                handler.applyDraftsToIncomingData(key, data, draftMetadataForKey && draftMetadataForKey.metadata, env.storePublish);
-                return;
-            }
-        }
-        if (draftMetadataForKey !== undefined) {
-            // WARNING: this code depends on the fact that RecordRepresentation
-            // fields get published before the root record.
-            if (draftMetadataForKey.refCount === 1) {
-                delete draftMetadata[key];
-            }
-            else {
-                draftMetadataForKey.refCount--;
-            }
-        }
-        // no handler could handle it so publish
-        env.storePublish(key, data);
-    };
-    // note the makeEnvironmentUiApiRecordDraftAware will eventually go away once the adapters become draft aware
-    return create(env, {
-        storePublish: { value: storePublish },
-        handleSuccessResponse: { value: handleSuccessResponse },
-    });
+function makeEnvironmentDraftAware(luvio, env, durableStore, handlers, draftQueue) {
+    const draftMetadata = {};
+    // setup existing store redirects when bootstrapping the environment
+    (async () => {
+        const mappings = await getDraftIdMappings(durableStore);
+        mappings.forEach((mapping) => {
+            const { draftKey, canonicalKey } = mapping;
+            env.storeRedirect(draftKey, canonicalKey);
+        });
+    })();
+    durableStore.registerOnChangedListener(async (changes) => {
+        const draftIdMappingsIds = [];
+        for (let i = 0, len = changes.length; i < len; i++) {
+            const change = changes[i];
+            if (change.segment === DRAFT_ID_MAPPINGS_SEGMENT) {
+                draftIdMappingsIds.push(...change.ids);
+            }
+        }
+        if (draftIdMappingsIds.length > 0) {
+            const mappings = await getDraftIdMappings(durableStore, draftIdMappingsIds);
+            mappings.forEach((mapping) => {
+                const { draftKey, canonicalKey } = mapping;
+                env.storeRedirect(draftKey, canonicalKey);
+            });
+        }
+    });
+    const handleSuccessResponse = async function (ingestAndBroadcastFunc, getResponseCacheKeysFunc) {
+        const queue = await draftQueue.getQueueActions();
+        if (queue.length === 0) {
+            return env.handleSuccessResponse(ingestAndBroadcastFunc, getResponseCacheKeysFunc);
+        }
+        const cacheKeySet = getResponseCacheKeysFunc();
+        for (const possibleKey of cacheKeySet.keys()) {
+            const key = typeof possibleKey === 'string' ? possibleKey : '';
+            const cacheKey = cacheKeySet.get(key);
+            for (const handler of handlers) {
+                if (cacheKey !== undefined &&
+                    handler.canRepresentationContainDraftMetadata(cacheKey.representationName)) {
+                    const metadata = await handler.getDraftMetadata(key);
+                    if (metadata !== undefined) {
+                        // if this key is related to a draft then mark it mergeable so
+                        // base environment revives it to staging store before ingestion
+                        cacheKey.mergeable = true;
+                        const existing = draftMetadata[key];
+                        if (existing === undefined) {
+                            draftMetadata[key] = { metadata, refCount: 1 };
+                        }
+                        else {
+                            draftMetadata[key] = { metadata, refCount: existing.refCount + 1 };
+                        }
+                    }
+                    break;
+                }
+            }
+        }
+        return env.handleSuccessResponse(ingestAndBroadcastFunc, () => cacheKeySet);
+    };
+    const storePublish = function (key, data) {
+        const draftMetadataForKey = draftMetadata[key];
+        for (const handler of handlers) {
+            if (handler.canHandlePublish(key)) {
+                handler.applyDraftsToIncomingData(key, data, draftMetadataForKey && draftMetadataForKey.metadata, env.storePublish);
+                return;
+            }
+        }
+        if (draftMetadataForKey !== undefined) {
+            // WARNING: this code depends on the fact that RecordRepresentation
+            // fields get published before the root record.
+            if (draftMetadataForKey.refCount === 1) {
+                delete draftMetadata[key];
+            }
+            else {
+                draftMetadataForKey.refCount--;
+            }
+        }
+        // no handler could handle it so publish
+        env.storePublish(key, data);
+    };
+    // note the makeEnvironmentUiApiRecordDraftAware will eventually go away once the adapters become draft aware
+    return create(env, {
+        storePublish: { value: storePublish },
+        handleSuccessResponse: { value: handleSuccessResponse },
+    });
 }
 
 export { AbstractResourceRequestActionHandler, CustomActionResultType, DRAFT_ERROR_CODE, DRAFT_ID_MAPPINGS_SEGMENT, DRAFT_SEGMENT, DraftActionOperationType, DraftActionStatus, DraftErrorFetchResponse, DraftFetchResponse, DraftManager, DraftQueueEventType, DraftQueueState, DraftSynthesisError, DurableDraftQueue, DurableDraftStore, ProcessActionResult, buildLuvioOverrideForDraftAdapters, createBadRequestResponse, createDeletedResponse, createDraftSynthesisErrorResponse, createInternalErrorResponse, createNotFoundResponse, createOkResponse, generateUniqueDraftActionId, isDraftSynthesisError, makeEnvironmentDraftAware, transformErrorToDraftSynthesisError };