@salesforce/lds-drafts 0.131.0

package/dist/ldsDrafts.js

@@ -0,0 +1,1718 @@
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+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";
+})(QueueOperationType || (QueueOperationType = {}));
+
+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 { 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 },
+    });
+}
+
+const DraftIdMappingKeyPrefix240 = 'DraftIdMapping::';
+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}`;
+}
+/**
+ *
+ * @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;
+}
+async function clearDraftIdSegment(durableStore) {
+    const entries = await durableStore.getAllEntries(DRAFT_ID_MAPPINGS_SEGMENT);
+    if (entries) {
+        const keys$1 = keys(entries);
+        if (keys$1.length > 0) {
+            await durableStore.evictEntries(keys$1, DRAFT_ID_MAPPINGS_SEGMENT);
+        }
+    }
+}
+
+/**
+ * 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;
+    };
+    return {
+        handlerId: id,
+        enqueue: (data) => {
+            return draftQueue.enqueue(id, data);
+        },
+        handleAction: handle,
+        buildPendingAction,
+        getQueueOperationsForCompletingDrafts: getQueueOperationsForCompletingDrafts,
+        handleReplaceAction: () => {
+            throw Error('replaceAction not supported for custom actions');
+        },
+        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;
+        }
+        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;
+        }
+        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);
+                // write the queue operations to the store prior to ingesting the result
+                await this.draftStore.completeAction(queueOperations);
+                await handler.handleActionCompleted(action, queueOperations, values(this.handlers));
+                this.retryIntervalMilliseconds = 0;
+                this.uploadingActionId = undefined;
+                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(targetActionId, sourceActionId) {
+        return this.replaceOrMergeActions(targetActionId, sourceActionId, false);
+    }
+    mergeActions(targetActionId, sourceActionId) {
+        return this.replaceOrMergeActions(targetActionId, sourceActionId, true);
+    }
+    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);
+    }
+    async getActionsForReplaceOrMerge(targetActionId, sourceActionId) {
+        const actions = await this.getQueueActions();
+        const target = actions.find((action) => action.id === targetActionId);
+        if (target === undefined) {
+            this.replacingAction = undefined;
+            await this.startQueueSafe();
+            throw Error(`targetActionId ${targetActionId} not found in the draft queue.`);
+        }
+        const source = actions.find((action) => action.id === sourceActionId);
+        if (source === undefined) {
+            this.replacingAction = undefined;
+            await this.startQueueSafe();
+            throw Error(`sourceActionId ${sourceActionId} not found in the draft queue.`);
+        }
+        return { target, source };
+    }
+    assertReplaceOrMergePrerequisites(target, source) {
+        // ensure actions are in a state to be replaced/merged
+        const { targetId: targetCacheKey, tag: targetTag, status: targetStatus, version: targetVersion, } = target;
+        const { targetId: sourceCacheKey, tag: sourceTag, status: sourceStatus, version: sourceVersion, } = source;
+        if (targetCacheKey !== sourceCacheKey) {
+            throw Error('Cannot replace/merge actions for different targetIds.');
+        }
+        if (targetTag !== sourceTag) {
+            throw Error('Cannot replace/merge actions for different tags.');
+        }
+        if (targetStatus === DraftActionStatus.Completed ||
+            targetStatus === DraftActionStatus.Uploading) {
+            throw Error(`Cannot replace/merge actions when targetAction is in ${targetStatus} status.`);
+        }
+        if (sourceStatus !== DraftActionStatus.Pending) {
+            throw Error(`Cannot replace/merge actions when sourceAction is in ${sourceStatus} status.`);
+        }
+        if (targetVersion !== sourceVersion) {
+            throw Error('Cannot replace/merge actions with different versions.');
+        }
+    }
+    async replaceOrMergeActions(targetActionId, sourceActionId, merge) {
+        // ids must be unique
+        if (targetActionId === sourceActionId) {
+            throw Error('targetActionId and sourceActionId cannot be the same.');
+        }
+        // cannot have a replace action already in progress
+        if (this.replacingAction !== undefined) {
+            throw Error('Cannot replace/merge actions while a replace/merge action operation is in progress.');
+        }
+        this.stopQueueManually();
+        const promise = this.getActionsForReplaceOrMerge(targetActionId, sourceActionId).then(async ({ target, source }) => {
+            // put in a try/finally block so we don't leave this.replacingAction
+            // indefinitely set
+            let updatedTarget;
+            try {
+                this.assertReplaceOrMergePrerequisites(target, source);
+                const handler = this.getHandler(target.handler);
+                updatedTarget = merge
+                    ? handler.mergeActions(target, source)
+                    : handler.handleReplaceAction(target, source);
+                // update the target
+                await this.draftStore.writeAction(updatedTarget);
+                await this.notifyChangedListeners({
+                    type: DraftQueueEventType.ActionUpdated,
+                    action: updatedTarget,
+                });
+                // remove the source from queue
+                await this.removeDraftAction(sourceActionId);
+            }
+            finally {
+                this.replacingAction = undefined;
+                await this.startQueueSafe();
+            }
+            return updatedTarget;
+        });
+        this.replacingAction = promise;
+        return promise;
+    }
+}
+
+const DRAFT_ACTION_KEY_JUNCTION = '__DraftAction__';
+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) {
+        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,
+                            },
+                        },
+                    });
+                }
+            }
+            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, allHandlers) {
+        const { data: request, tag } = action;
+        const { method } = request;
+        if (method === 'delete') {
+            return this.evictKey(tag);
+        }
+        const recordsToIngest = [];
+        recordsToIngest.push({
+            response: action.response.body,
+            synchronousIngest: this.synchronousIngest.bind(this),
+            buildCacheKeysForResponse: this.buildCacheKeysFromResponse.bind(this),
+        });
+        const recordsNeedingReplay = queueOperations.filter((x) => x.type === QueueOperationType.Update);
+        for (const recordNeedingReplay of recordsNeedingReplay) {
+            const { action } = recordNeedingReplay;
+            if (isResourceRequestAction(action)) {
+                // We can't assume the queue operation is for our handler, have to find the handler.
+                const handler = allHandlers.find((h) => h.handlerId === action.handler);
+                if (handler !== undefined) {
+                    const record = await handler.getDataForAction(action);
+                    if (record !== undefined) {
+                        recordsToIngest.push({
+                            response: record,
+                            synchronousIngest: handler.synchronousIngest.bind(handler),
+                            buildCacheKeysForResponse: handler.buildCacheKeysFromResponse.bind(handler),
+                        });
+                    }
+                }
+            }
+        }
+        await this.ingestResponses(recordsToIngest, action);
+    }
+    handleReplaceAction(targetAction, sourceAction) {
+        //reject if the action to replace is a POST action
+        const pendingAction = targetAction;
+        if (pendingAction.data.method === 'post') {
+            throw Error('Cannot replace a POST action');
+        }
+        if (this.isActionOfType(targetAction) &&
+            this.isActionOfType(sourceAction)) {
+            targetAction.status = DraftActionStatus.Pending;
+            targetAction.data = sourceAction.data;
+            return targetAction;
+        }
+        else {
+            throw Error('Incompatible Action types to replace one another');
+        }
+    }
+    mergeActions(targetAction, sourceAction) {
+        const { id: targetId, data: targetData, metadata: targetMetadata, timestamp: targetTimestamp, } = targetAction;
+        const { method: targetMethod, body: targetBody } = targetData;
+        const { data: sourceData, metadata: sourceMetadata } = sourceAction;
+        const { method: sourceMethod, body: sourceBody } = sourceData;
+        if (targetMethod.toLowerCase() === 'delete' || sourceMethod.toLowerCase() === 'delete') {
+            throw Error('Cannot merge DELETE actions.');
+        }
+        if (targetMethod.toLowerCase() === 'patch' && sourceMethod.toLowerCase() === 'post') {
+            // overlaying a POST over a PATCH is not supported
+            throw Error('Cannot merge a POST action over top of a PATCH action.');
+        }
+        // overlay top-level properties, maintain target's timestamp and id
+        const merged = {
+            ...targetAction,
+            ...sourceAction,
+            timestamp: targetTimestamp,
+            id: targetId,
+        };
+        // overlay data
+        // NOTE: we stick to the target's ResourceRequest properties (except body
+        // which is merged) because we don't want to overwrite a POST with a PATCH
+        // (all other cases should be fine or wouldn't have passed pre-requisites)
+        merged.data = {
+            ...targetData,
+            body: this.mergeRequestBody(targetBody, sourceBody),
+        };
+        // overlay metadata
+        merged.metadata = { ...targetMetadata, ...sourceMetadata };
+        // put status back to pending to auto upload if queue is active and targed is at the head.
+        merged.status = DraftActionStatus.Pending;
+        return merged;
+    }
+    shouldDeleteActionByTagOnRemoval(action) {
+        return action.data.method === 'post';
+    }
+    updateMetadata(_existingMetadata, incomingMetadata) {
+        return incomingMetadata;
+    }
+    isActionOfType(action) {
+        return action.handler === this.handlerId;
+    }
+    async reingestRecord(action) {
+        const record = await this.getDataForAction(action);
+        if (record !== undefined) {
+            await this.ingestResponses([
+                {
+                    response: record,
+                    synchronousIngest: this.synchronousIngest.bind(this),
+                    buildCacheKeysForResponse: this.buildCacheKeysFromResponse.bind(this),
+                },
+            ], action);
+        }
+        else {
+            await this.evictKey(action.tag);
+        }
+    }
+    // Given an action for this handler this method should return the draft IDs.
+    // Most of the time it will simply be the targetId, but certain handlers might
+    // have multiple draft-created IDs so they would override this to return them.
+    getDraftIdsFromAction(action) {
+        return [action.targetId];
+    }
+    async ingestResponses(responses, action) {
+        const luvio = this.getLuvio();
+        await luvio.handleSuccessResponse(() => {
+            if (action.status === DraftActionStatus.Completed) {
+                const mappings = this.getRedirectMappings(action);
+                if (mappings) {
+                    mappings.forEach((mapping) => {
+                        luvio.storeRedirect(mapping.draftKey, mapping.canonicalKey);
+                    });
+                }
+            }
+            for (const entry of responses) {
+                const { response, synchronousIngest } = entry;
+                synchronousIngest(response, action);
+            }
+            return luvio.storeBroadcast();
+        }, 
+        // getTypeCacheKeysRecord uses the response, not the full path factory
+        // so 2nd parameter will be unused
+        () => {
+            const keySet = new StoreKeyMap();
+            for (const entry of responses) {
+                const { response, buildCacheKeysForResponse } = entry;
+                const set = buildCacheKeysForResponse(response);
+                for (const key of set.keys()) {
+                    const value = set.get(key);
+                    if (value !== undefined) {
+                        keySet.set(key, value);
+                    }
+                }
+            }
+            return keySet;
+        });
+    }
+    async evictKey(key) {
+        const luvio = this.getLuvio();
+        await luvio.handleSuccessResponse(() => {
+            luvio.storeEvict(key);
+            return luvio.storeBroadcast();
+        }, () => {
+            return new StoreKeyMap();
+        });
+    }
+}
+function actionsForTag(tag, queue) {
+    return queue.filter((action) => action.tag === tag);
+}
+function deleteActionsForTag(tag, queue) {
+    return queue.filter((action) => action.tag === tag && action.data.method === 'delete');
+}
+function isResourceRequestAction(action) {
+    const dataAsAny = action.data;
+    return (dataAsAny !== undefined && dataAsAny.method !== undefined && dataAsAny.body !== undefined);
+}
+
+/**
+ * Denotes what kind of operation a DraftQueueItem represents.
+ */
+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 = {};
+    // in 246 luvio took charge of persisting redirect mappings, this needs to stick around
+    // for a couple of releases to support older environments
+    // 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);
+        });
+        await env.storeBroadcast(env.rebuildSnapshot, env.snapshotAvailable);
+        await clearDraftIdSegment(durableStore);
+    })();
+    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 };