@salesforce/lds-drafts 0.1.0-dev1

package/dist/ldsDrafts.js

@@ -0,0 +1,1373 @@
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+import { HttpStatusCode } from '@luvio/engine';
+import { AsyncWorkerPool } from '@salesforce/lds-utils-adapters';
+export { uuidv4 } 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 when starting to upload and process an action
+     */
+    DraftQueueEventType["ActionUploading"] = "uploading";
+    /**
+     * 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 = {}));
+
+const { keys, create, assign, values } = Object;
+const { stringify, parse } = JSON;
+const { isArray } = Array;
+
+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);
+}
+
+/**
+ * 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(),
+        handleActionReplaced: () => Promise.resolve(),
+        shouldDeleteActionByTagOnRemoval: () => false,
+        updateMetadata: (existing, incoming) => incoming,
+        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.logger = typeof __nimbus !== 'undefined' &&
+            __nimbus.plugins !== undefined &&
+            __nimbus.plugins.JSLoggerPlugin !== undefined
+            ? __nimbus.plugins.JSLoggerPlugin
+            : undefined;
+        this.handlers = {};
+        this.draftStore = draftStore;
+        this.workerPool = new AsyncWorkerPool(1);
+    }
+    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,
+            draftCount: this.draftStore.getCount(),
+        });
+        const result = await this.processNextAction();
+        switch (result) {
+            case ProcessActionResult.BLOCKED_ON_ERROR:
+                this.state = DraftQueueState.Error;
+                return Promise.reject('Unable to start queue - first action is in error state');
+            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(false);
+        return this.notifyChangedListeners({
+            type: DraftQueueEventType.QueueStateChanged,
+            state: DraftQueueState.Stopped,
+            draftCount: this.draftStore.getCount(),
+        });
+    }
+    stopQueueWhileRunning(action) {
+        this.stopQueueManually(true);
+        return action().finally(() => {
+            this.startQueueSafe();
+        });
+    }
+    /**
+     * Used to stop the queue within DraftQueue without user interaction
+     */
+    stopQueueManually(internalReason) {
+        if (this.logger) {
+            this.logger.logInfo(internalReason
+                ? 'Draft queue stopped for internal reason'
+                : 'Draft queue stopped by app');
+        }
+        if (this.timeoutHandler) {
+            clearTimeout(this.timeoutHandler);
+            this.timeoutHandler = undefined;
+        }
+        this.state = DraftQueueState.Stopped;
+    }
+    async getQueueActions() {
+        const drafts = (await this.draftStore.getAllDrafts());
+        const 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,
+                    draftCount: this.draftStore.getCount(),
+                });
+                await handler.handleActionEnqueued(pendingAction, queue);
+                if (this.state === DraftQueueState.Started) {
+                    this.processNextAction();
+                }
+                return pendingAction;
+            },
+        });
+    }
+    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,
+                    draftCount: this.draftStore.getCount(),
+                });
+                if (this.state === DraftQueueState.Started) {
+                    this.processNextAction();
+                }
+            },
+        });
+    }
+    async actionFailed(action, retry, retryDelayInMs, actionDataChanged) {
+        if (actionDataChanged === true) {
+            await this.draftStore.writeAction({
+                ...action,
+                status: DraftActionStatus.Pending,
+            });
+        }
+        this.uploadingActionId = undefined;
+        if (retry && this.state !== DraftQueueState.Stopped) {
+            this.state = DraftQueueState.Waiting;
+            return retryDelayInMs !== undefined
+                ? this.scheduleRetryWithSpecifiedDelay(retryDelayInMs)
+                : 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;
+            await this.notifyChangedListeners({
+                type: DraftQueueEventType.ActionFailed,
+                action: action,
+                draftCount: this.draftStore.getCount(),
+            });
+            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;
+        }
+        await this.notifyChangedListeners({
+            type: DraftQueueEventType.ActionUploading,
+            action: { ...action, status: DraftActionStatus.Uploading },
+            draftCount: this.draftStore.getCount(),
+        });
+        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,
+            draftCount: this.draftStore.getCount(),
+        });
+    }
+    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,
+            draftCount: this.draftStore.getCount(),
+        });
+        if (this.userState === DraftQueueState.Started &&
+            this.state !== DraftQueueState.Started &&
+            this.replacingAction === undefined) {
+            await this.startQueue();
+        }
+    }
+    async updateDraftAction(action) {
+        // stop queue manually
+        this.stopQueueManually(true);
+        const actionStatus = await this.statusOfAction(action.id);
+        if (actionStatus === DraftActionStatus.Uploading) {
+            return Promise.reject('cannot update an uploading action');
+        }
+        // save the action into the draft store
+        await this.draftStore.writeAction(action);
+        // make the handler replay these drafts on the record
+        const handler = this.getHandler(action.handler);
+        const queue = await this.getQueueActions();
+        await handler.handleActionEnqueued(action, queue);
+        // start queue safely
+        return this.startQueueSafe();
+    }
+    async statusOfAction(actionId) {
+        const queue = await this.getQueueActions();
+        const actions = queue.filter((action) => action.id === actionId);
+        if (actions.length === 0) {
+            return Promise.reject('cannot update non-existent action');
+        }
+        const action = actions[0];
+        return action.status;
+    }
+    replaceAction(targetActionId, sourceActionId) {
+        return this.replaceOrMergeActions(targetActionId, sourceActionId, false);
+    }
+    mergeActions(targetActionId, sourceActionId) {
+        return this.replaceOrMergeActions(targetActionId, sourceActionId, true);
+    }
+    async retryAction(actionId) {
+        this.stopQueueManually(true);
+        const actions = await this.getQueueActions();
+        const target = actions[0];
+        if (!target || target.id !== actionId) {
+            throw Error(`Action ${actionId} not found at the head of the draft queue`);
+        }
+        if (!isDraftError(target)) {
+            throw Error(`Action ${actionId} is not in Error state`);
+        }
+        let pendingAction = {
+            ...target,
+            status: DraftActionStatus.Pending,
+            error: undefined,
+        };
+        await this.draftStore.writeAction(pendingAction);
+        await this.notifyChangedListeners({
+            type: DraftQueueEventType.ActionUpdated,
+            action: pendingAction,
+            draftCount: this.draftStore.getCount(),
+        });
+        await this.startQueueSafe();
+        return pendingAction;
+    }
+    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,
+            draftCount: this.draftStore.getCount(),
+        });
+        return action;
+    }
+    async scheduleRetryWithSpecifiedDelay(retryDelayInMs) {
+        await this.notifyChangedListeners({
+            type: DraftQueueEventType.QueueStateChanged,
+            state: DraftQueueState.Waiting,
+            draftCount: this.draftStore.getCount(),
+        });
+        this.timeoutHandler = setTimeout(() => {
+            if (this.state !== DraftQueueState.Stopped) {
+                this.processNextAction();
+            }
+        }, retryDelayInMs);
+    }
+    async scheduleRetry() {
+        const newInterval = this.retryIntervalMilliseconds * 2;
+        this.retryIntervalMilliseconds = Math.min(Math.max(newInterval, this.minimumRetryInterval), this.maximumRetryInterval);
+        return this.scheduleRetryWithSpecifiedDelay(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(true);
+        const promise = this.getActionsForReplaceOrMerge(targetActionId, sourceActionId).then(async ({ target, source }) => {
+            // put in a try/finally block so we don't leave this.replacingAction
+            // indefinitely set
+            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 handler.handleActionReplaced(updatedTarget, source);
+                await this.notifyChangedListeners({
+                    type: DraftQueueEventType.ActionUpdated,
+                    action: updatedTarget,
+                    draftCount: this.draftStore.getCount(),
+                });
+                // remove the source from queue
+                await this.removeDraftAction(sourceActionId);
+            }
+            finally {
+                this.replacingAction = undefined;
+                try {
+                    await this.startQueueSafe();
+                }
+                catch {
+                    // An error starting the queue should not bubble up from this method
+                }
+            }
+            return updatedTarget;
+        });
+        this.replacingAction = promise;
+        return promise;
+    }
+}
+
+function clone(obj) {
+    return parse(stringify(obj));
+}
+
+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];
+                // clone draft so we don't expose the internal draft store
+                actionArray.push(clone(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);
+    }
+    getCount() {
+        return keys(this.draftStore).length;
+    }
+    /**
+     * Runs a write operation against the draft store, if the initial
+     * revive is still in progress, the action gets enqueued to run once the
+     * 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 (process.env.NODE_ENV !== 'production') {
+                        // the `version` property was introduced in 242, we should assert version
+                        // exists once we are sure there are no durable stores that contain
+                        // versionless actions
+                        if (action.version && action.version !== '242.0.0') {
+                            return Promise.reject('Unexpected draft action version found in the durable store');
+                        }
+                    }
+                    draftStore[action.id] = action;
+                }
+                return this.runQueuedOperations();
+            })
+                .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();
+    }
+}
+
+/**
+ * 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["ItemUploading"] = "uploading";
+    DraftQueueOperationType["ItemDeleted"] = "deleted";
+    DraftQueueOperationType["ItemCompleted"] = "completed";
+    DraftQueueOperationType["ItemFailed"] = "failed";
+    DraftQueueOperationType["ItemUpdated"] = "updated";
+    DraftQueueOperationType["QueueStateChanged"] = "queueStateChanged";
+})(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 {
+    shouldEmitEvent(event) {
+        return this.draftEventsShouldBeEmitted.includes(event.type);
+    }
+    constructor(draftQueue) {
+        this.listeners = [];
+        this.draftEventsShouldBeEmitted = [
+            DraftQueueEventType.ActionAdded,
+            DraftQueueEventType.ActionUploading,
+            DraftQueueEventType.ActionCompleted,
+            DraftQueueEventType.ActionDeleted,
+            DraftQueueEventType.ActionFailed,
+            DraftQueueEventType.ActionUpdated,
+            DraftQueueEventType.QueueStateChanged,
+        ];
+        this.draftQueue = draftQueue;
+        draftQueue.registerOnChangedListener((event) => {
+            if (this.shouldEmitEvent(event)) {
+                return this.callListeners(event);
+            }
+            return Promise.resolve();
+        });
+    }
+    draftQueueEventTypeToOperationType(type) {
+        switch (type) {
+            case DraftQueueEventType.ActionAdded:
+                return DraftQueueOperationType.ItemAdded;
+            case DraftQueueEventType.ActionUploading:
+                return DraftQueueOperationType.ItemUploading;
+            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');
+        }
+    }
+    /**
+     * 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);
+        });
+    }
+    /**
+     * 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();
+    }
+    /**
+     * Stops the draft queue manually without notifying the user and then runs the passed action.
+     * After the action is completed it will safely start the queue if the user had set it to be
+     * started.
+     */
+    stopQueueWhileRunning(action) {
+        return this.draftQueue.stopQueueWhileRunning(action);
+    }
+    /**
+     * 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, _version = undefined) {
+        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();
+            };
+        });
+    }
+    async mergePerformQuickAction(actionId, fields) {
+        if (!this.isValidFieldMap(fields)) {
+            return Promise.reject('fields is not valid');
+        }
+        const queue = await this.draftQueue.getQueueActions();
+        const actions = queue.filter((action) => action.id === actionId);
+        if (actions.length === 0) {
+            return Promise.reject('cannot edit non-existent action');
+        }
+        const action = actions[0];
+        if (!this.isPerformQuickActionDraft(action, 'post')) {
+            return Promise.reject('cannot edit incompatible action type or uploading actions');
+        }
+        action.data.body.fields = { ...action.data.body.fields, ...fields };
+        action.status = DraftActionStatus.Pending;
+        await this.draftQueue.updateDraftAction(action);
+        return this.buildDraftQueueItem(action);
+    }
+    isValidFieldMap(fields) {
+        const keys$1 = keys(fields);
+        const validTypes = ['string', 'number', 'boolean'];
+        for (let i = 0; i < keys$1.length; i++) {
+            const key = keys$1[i];
+            const value = fields[key];
+            if (!validTypes.includes(typeof value) && value !== null) {
+                return false;
+            }
+        }
+        return true;
+    }
+    isPerformQuickActionDraft(action, method) {
+        const data = action.data;
+        const isPerformQuickAction = data.basePath.startsWith('/ui-api/actions/perform-quick-action/');
+        const methodMatches = data.method === method;
+        const notUploading = action.status !== DraftActionStatus.Uploading;
+        return isPerformQuickAction && methodMatches && notUploading;
+    }
+    async mergePerformUpdateRecordQuickAction(actionId, fields) {
+        if (!this.isValidFieldMap(fields)) {
+            return Promise.reject('fields is not valid');
+        }
+        const queue = await this.draftQueue.getQueueActions();
+        const actions = queue.filter((action) => action.id === actionId);
+        if (actions.length === 0) {
+            return Promise.reject('cannot edit non-existent action');
+        }
+        const action = actions[0];
+        if (!this.isPerformQuickActionDraft(action, 'patch')) {
+            return Promise.reject('cannot edit incompatible action type or uploading actions');
+        }
+        const data = action.data;
+        data.body.fields = { ...data.body.fields, ...fields };
+        action.status = DraftActionStatus.Pending;
+        await this.draftQueue.updateDraftAction(action);
+        return this.buildDraftQueueItem(action);
+    }
+    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 = DraftQueueOperationType.QueueStateChanged;
+        }
+        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);
+        });
+    }
+    /**
+     * Retries a draft action that is in error state without any modification.
+     *
+     * @param actionId The id of the draft action that should be retried
+     * @throws If the draft action is not at the front of the draft queue or is not
+     * in error state.
+     */
+    async retryAction(actionId) {
+        return this.draftQueue.retryAction(actionId).then((updatedAction) => {
+            return this.buildDraftQueueItem(updatedAction);
+        });
+    }
+}
+function isResourceRequestAction(action) {
+    const dataAsAny = action.data;
+    return (dataAsAny !== undefined && dataAsAny.method !== undefined && dataAsAny.body !== undefined);
+}
+
+export { CustomActionResultType, DRAFT_ERROR_CODE, DRAFT_SEGMENT, DraftActionOperationType, DraftActionStatus, DraftErrorFetchResponse, DraftFetchResponse, DraftManager, DraftQueueEventType, DraftQueueState, DraftSynthesisError, DurableDraftQueue, DurableDraftStore, ProcessActionResult, QueueOperationType, createBadRequestResponse, createDeletedResponse, createDraftSynthesisErrorResponse, createInternalErrorResponse, createNotFoundResponse, createOkResponse, generateUniqueDraftActionId, isDraftSynthesisError, transformErrorToDraftSynthesisError };