@salesforce/lds-drafts 1.100.1

package/LICENSE.txt

@@ -0,0 +1,82 @@
+Terms of Use
+
+Copyright 2022 Salesforce, Inc. All rights reserved.
+
+These Terms of Use govern the download, installation, and/or use of this
+software provided by Salesforce, Inc. ("Salesforce") (the "Software"), were
+last updated on April 15, 2022, and constitute a legally binding
+agreement between you and Salesforce. If you do not agree to these Terms of
+Use, do not install or use the Software.
+
+Salesforce grants you a worldwide, non-exclusive, no-charge, royalty-free
+copyright license to reproduce, prepare derivative works of, publicly
+display, publicly perform, sublicense, and distribute the Software and
+derivative works subject to these Terms. These Terms shall be included in
+all copies or substantial portions of the Software.
+
+Subject to the limited rights expressly granted hereunder, Salesforce
+reserves all rights, title, and interest in and to all intellectual
+property subsisting in the Software. No rights are granted to you hereunder
+other than as expressly set forth herein. Users residing in countries on
+the United States Office of Foreign Assets Control sanction list, or which
+are otherwise subject to a US export embargo, may not use the Software.
+
+Implementation of the Software may require development work, for which you
+are responsible. The Software may contain bugs, errors and
+incompatibilities and is made available on an AS IS basis without support,
+updates, or service level commitments.
+
+Salesforce reserves the right at any time to modify, suspend, or
+discontinue, the Software (or any part thereof) with or without notice. You
+agree that Salesforce shall not be liable to you or to any third party for
+any modification, suspension, or discontinuance.
+
+You agree to defend Salesforce against any claim, demand, suit or
+proceeding made or brought against Salesforce by a third party arising out
+of or accruing from (a) your use of the Software, and (b) any application
+you develop with the Software that infringes any copyright, trademark,
+trade secret, trade dress, patent, or other intellectual property right of
+any person or defames any person or violates their rights of publicity or
+privacy (each a "Claim Against Salesforce"), and will indemnify Salesforce
+from any damages, attorney fees, and costs finally awarded against
+Salesforce as a result of, or for any amounts paid by Salesforce under a
+settlement approved by you in writing of, a Claim Against Salesforce,
+provided Salesforce (x) promptly gives you written notice of the Claim
+Against Salesforce, (y) gives you sole control of the defense and
+settlement of the Claim Against Salesforce (except that you may not settle
+any Claim Against Salesforce unless it unconditionally releases Salesforce
+of all liability), and (z) gives you all reasonable assistance, at your
+expense.
+
+WITHOUT LIMITING THE GENERALITY OF THE FOREGOING, THE SOFTWARE IS NOT
+SUPPORTED AND IS PROVIDED "AS IS," WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED. IN NO EVENT SHALL SALESFORCE HAVE ANY LIABILITY FOR ANY DAMAGES,
+INCLUDING, BUT NOT LIMITED TO, DIRECT, INDIRECT, SPECIAL, INCIDENTAL,
+PUNITIVE, OR CONSEQUENTIAL DAMAGES, OR DAMAGES BASED ON LOST PROFITS, DATA,
+OR USE, IN CONNECTION WITH THE SOFTWARE, HOWEVER CAUSED AND WHETHER IN
+CONTRACT, TORT, OR UNDER ANY OTHER THEORY OF LIABILITY, WHETHER OR NOT YOU
+HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+These Terms of Use shall be governed exclusively by the internal laws of
+the State of California, without regard to its conflicts of laws
+rules. Each party hereby consents to the exclusive jurisdiction of the
+state and federal courts located in San Francisco County, California to
+adjudicate any dispute arising out of or relating to these Terms of Use and
+the download, installation, and/or use of the Software. Except as expressly
+stated herein, these Terms of Use constitute the entire agreement between
+the parties, and supersede all prior and contemporaneous agreements,
+proposals, or representations, written or oral, concerning their subject
+matter. No modification, amendment, or waiver of any provision of these
+Terms of Use shall be effective unless it is by an update to these Terms of
+Use that Salesforce makes available, or is in writing and signed by the
+party against whom the modification, amendment, or waiver is to be
+asserted.
+
+Data Privacy: Salesforce may collect, process, and store device,
+system, and other information related to your use of the Software. This
+information includes, but is not limited to, IP address, user metrics, and
+other data ("Usage Data"). Salesforce may use Usage Data for analytics,
+product development, and marketing purposes. You acknowledge that files
+generated in conjunction with the Software may contain sensitive or
+confidential data, and you are solely responsible for anonymizing and
+protecting such data.

package/dist/DraftAwareAdapter.d.ts

@@ -0,0 +1,6 @@
+import type { DispatchResourceRequestContext, Luvio, Snapshot } from '@luvio/engine';
+import type { AbstractResourceRequestActionHandler } from './actionHandlers/AbstractResourceRequestActionHandler';
+export type AdapterBuildNetworkSnapshot<Config, Response> = (luvio: Luvio, config: Config, dispatchResourceRequestContext?: DispatchResourceRequestContext) => Promise<Snapshot<Response>>;
+export declare function buildLuvioOverrideForDraftAdapters<ResponseType = unknown, DraftMetadata = unknown>(luvio: Luvio, handler: AbstractResourceRequestActionHandler<ResponseType, DraftMetadata>, extractTargetIdFromCacheKey: (cacheKey: string) => string | undefined, options?: {
+    forDeleteAdapter?: boolean;
+}): Luvio;

package/dist/DraftFetchResponse.d.ts

@@ -0,0 +1,28 @@
+import type { FetchErrorResponse, FetchResponse, Headers } from '@luvio/engine';
+import { HttpStatusCode } from '@luvio/engine';
+import type { DraftSynthesisErrorType, DraftSynthesisError } from './DraftSynthesisError';
+export declare const DRAFT_ERROR_CODE = "DRAFT_ERROR";
+export declare class DraftFetchResponse<T> implements FetchResponse<T> {
+    status: HttpStatusCode;
+    body: T;
+    headers: Headers;
+    constructor(status: HttpStatusCode, body: T);
+    get statusText(): string;
+    get ok(): boolean;
+}
+export declare class DraftErrorFetchResponse implements FetchErrorResponse {
+    status: HttpStatusCode;
+    body: unknown;
+    ok: boolean;
+    headers: Headers;
+    errorType: 'fetchResponse';
+    constructor(status: HttpStatusCode.BadRequest | HttpStatusCode.ServerError | HttpStatusCode.NotFound, body: unknown);
+    get statusText(): string;
+}
+export declare function createOkResponse<T>(body: T): DraftFetchResponse<T>;
+export declare function createBadRequestResponse(body: unknown): DraftErrorFetchResponse;
+export declare function createNotFoundResponse(body: unknown): DraftErrorFetchResponse;
+export declare function transformErrorToDraftSynthesisError(error: Error | DraftSynthesisError<unknown>): DraftErrorFetchResponse;
+export declare function createDraftSynthesisErrorResponse(message?: string, errorType?: DraftSynthesisErrorType): DraftErrorFetchResponse;
+export declare function createDeletedResponse(): DraftFetchResponse<void>;
+export declare function createInternalErrorResponse(): DraftErrorFetchResponse;

package/dist/DraftIdMapping.d.ts

@@ -0,0 +1,12 @@
+import type { DurableStore } from '@luvio/environments';
+export interface DraftKeyMapping {
+    draftKey: string;
+    canonicalKey: string;
+}
+export declare const DRAFT_ID_MAPPINGS_SEGMENT = "DRAFT_ID_MAPPINGS";
+export declare function generateDraftIdMappingKey(draftIdMapping: DraftKeyMapping): string;
+/**
+ *
+ * @param mappingIds (optional) requested mapping ids, if undefined all will be retrieved
+ */
+export declare function getDraftIdMappings(durableStore: DurableStore, mappingIds?: string[]): Promise<DraftKeyMapping[]>;

package/dist/DraftManager.d.ts

@@ -0,0 +1,161 @@
+import type { CustomActionResult } from './actionHandlers/CustomActionHandler';
+import type { DraftActionStatus, DraftQueue, DraftActionMetadata } from './DraftQueue';
+import { DraftQueueState } from './DraftQueue';
+/**
+ * Representation of the current state of the draft queue.
+ * Includes the overall state as well as a list of draft
+ * items that are currently in the queue.
+ */
+export interface DraftManagerState {
+    queueState: DraftQueueState;
+    items: DraftQueueItem[];
+}
+export type DraftQueueItemMetadata = {
+    [key: string]: string;
+};
+export type DraftManagerCustomActionExecutor = (item: DraftQueueItem, completed: (result: CustomActionResult) => void) => void;
+/**
+ * An item in the draft queue that loosely maps to
+ * a DraftAction
+ */
+export interface DraftQueueItem {
+    /** The id of the Draft Action Item */
+    id: string;
+    /** The unique id of the target item */
+    targetId?: string;
+    /** The current status of this item */
+    state: DraftActionStatus;
+    /** The type of operation this item represents */
+    operationType: DraftActionOperationType;
+    /** Timestamp as unix epoch time */
+    timestamp: number;
+    /** undefined unless item is in an error state */
+    error?: undefined | DraftQueueItemError;
+    /** The stored metadata for the draft queue item */
+    metadata: DraftQueueItemMetadata;
+}
+/**
+ * An error of a draft action that was submitted and failed
+ */
+export interface DraftQueueItemError {
+    /** The status code of the response */
+    status: number;
+    /** The headers of the response */
+    headers: {
+        [key: string]: string;
+    };
+    /** A flag representing the status of the response */
+    ok: boolean;
+    /** A summary of the response */
+    statusText: string;
+    /** A stringified object representing the body of the response */
+    bodyString: string;
+}
+/**
+ * Denotes what kind of operation a DraftQueueItem represents.
+ */
+export declare enum DraftActionOperationType {
+    Create = "create",
+    Update = "update",
+    Delete = "delete",
+    Custom = "custom"
+}
+export declare enum DraftQueueOperationType {
+    ItemAdded = "added",
+    ItemDeleted = "deleted",
+    ItemCompleted = "completed",
+    ItemFailed = "failed",
+    ItemUpdated = "updated",
+    QueueStarted = "started",
+    QueueStopped = "stopped"
+}
+/**
+ * A closure that draft queue change listeners pass to
+ * receive updates when the draft queue changes.
+ */
+export declare type DraftQueueListener = (state: DraftManagerState, operationType: DraftQueueOperationType, queueItem?: DraftQueueItem) => void;
+export declare class DraftManager {
+    private draftQueue;
+    private listeners;
+    constructor(draftQueue: DraftQueue);
+    private shouldEmitDraftEvent;
+    private draftQueueEventTypeToOperationType;
+    private draftQueueStateToOperationType;
+    /**
+     * 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: string, targetId: string, tag: string, metadata: DraftActionMetadata): Promise<DraftQueueItem>;
+    /**
+     * 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(): Promise<DraftManagerState>;
+    /**
+     * Starts the draft queue and begins processing the first item in the queue.
+     */
+    startQueue(): Promise<void>;
+    /**
+     * Stops the draft queue from processing more draft items after any current
+     * in progress items are finished.
+     */
+    stopQueue(): Promise<void>;
+    /**
+     * 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: DraftQueueListener): () => Promise<void>;
+    /**
+     * Creates a custom action handler for the given handler
+     * @param handlerId
+     * @param executor
+     * @returns
+     */
+    setCustomActionExecutor(handlerId: string, executor: DraftManagerCustomActionExecutor): Promise<() => Promise<void>>;
+    private buildDraftQueueItem;
+    private callListeners;
+    /**
+     * 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: string): Promise<DraftManagerState>;
+    /**
+     * 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: string, withActionId: string): Promise<DraftQueueItem>;
+    /**
+     * 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.
+     */
+    mergeAction(targetActionId: string, sourceActionId: string): Promise<DraftQueueItem>;
+    /**
+     * 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: string, metadata: DraftQueueItemMetadata): Promise<DraftQueueItem>;
+}

package/dist/DraftQueue.d.ts

@@ -0,0 +1,235 @@
+import type { FetchResponse } from '@luvio/engine';
+import type { ActionHandler } from './actionHandlers/ActionHandler';
+import type { CustomActionExecutor } from './actionHandlers/CustomActionHandler';
+export declare enum DraftActionStatus {
+    Pending = "pending",
+    Uploading = "uploading",
+    Error = "error",
+    Completed = "completed"
+}
+export type DraftActionMetadata = {
+    [key: string]: string;
+};
+interface BaseDraftAction<Data> {
+    status: DraftActionStatus;
+    id: string;
+    /** Timestamp as unix epoch time */
+    timestamp: number;
+    metadata: DraftActionMetadata;
+    /** typically the cache key */
+    targetId: string;
+    /** typically the unique record ID  */
+    tag: string;
+    /** the handlerId */
+    handler: string;
+    /** the data being enqueued */
+    data: Data;
+    version: '242.0.0';
+}
+export interface CompletedDraftAction<Data, Response> extends BaseDraftAction<Data> {
+    status: DraftActionStatus.Completed;
+    response: FetchResponse<Response>;
+}
+export interface PendingDraftAction<Data> extends BaseDraftAction<Data> {
+    status: DraftActionStatus.Pending;
+}
+export interface ErrorDraftAction<Data> extends BaseDraftAction<Data> {
+    status: DraftActionStatus.Error;
+    error: any;
+}
+export interface UploadingDraftAction<Data> extends BaseDraftAction<Data> {
+    status: DraftActionStatus.Uploading;
+}
+export declare function isDraftCompleted<Data, Response>(draft: BaseDraftAction<Data>): draft is CompletedDraftAction<Data, Response>;
+export declare function isDraftError<Data>(draft: BaseDraftAction<Data>): draft is ErrorDraftAction<Data>;
+export declare function isDraftQueueStateChangeEvent(event: DraftQueueEvent): event is DraftQueueStateChangedEvent;
+export type DraftAction<Data, Response> = CompletedDraftAction<Data, Response> | PendingDraftAction<Data> | ErrorDraftAction<Data> | UploadingDraftAction<Data>;
+export type DraftQueueChangeListener = (event: DraftQueueEvent) => Promise<void>;
+export declare enum ProcessActionResult {
+    ACTION_ERRORED = "ERROR",
+    ACTION_SUCCEEDED = "SUCCESS",
+    NO_ACTION_TO_PROCESS = "NO_ACTION_TO_PROCESS",
+    ACTION_ALREADY_PROCESSING = "ACTION_ALREADY_PROCESSING",
+    NETWORK_ERROR = "NETWORK_ERROR",
+    BLOCKED_ON_ERROR = "BLOCKED_ON_ERROR",
+    CUSTOM_ACTION_WAITING = "CUSTOM_ACTION_WAITING"
+}
+export declare enum DraftQueueState {
+    /** Currently processing an item in the queue or queue is empty and waiting to process the next item. */
+    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.
+     */
+    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.
+     */
+    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().
+     */
+    Waiting = "waiting"
+}
+export declare enum DraftQueueEventType {
+    /**
+     * Triggered after an action had been added to the queue
+     */
+    ActionAdded = "added",
+    /**
+     * Triggered once an action failed
+     */
+    ActionFailed = "failed",
+    /**
+     * Triggered after an action has been deleted from the queue
+     */
+    ActionDeleted = "deleted",
+    /**
+     * Triggered after an action has been completed and after it has been removed from the queue
+     */
+    ActionCompleted = "completed",
+    /**
+     * Triggered after an action has been updated by the updateAction API
+     */
+    ActionUpdated = "updated",
+    /**
+     * Triggered after the Draft Queue state changes
+     */
+    QueueStateChanged = "state"
+}
+export interface DraftQueueAddEvent {
+    type: DraftQueueEventType.ActionAdded;
+    action: PendingDraftAction<unknown>;
+}
+export interface DraftQueueDeleteEvent {
+    type: DraftQueueEventType.ActionDeleted;
+    action: DraftAction<unknown, unknown>;
+}
+export interface DraftQueueCompleteEvent {
+    type: DraftQueueEventType.ActionCompleted;
+    action: CompletedDraftAction<unknown, unknown>;
+}
+export interface DraftQueueActionFailedEvent {
+    type: DraftQueueEventType.ActionFailed;
+    action: ErrorDraftAction<unknown>;
+}
+export interface DraftQueueActionUpdatedEvent {
+    type: DraftQueueEventType.ActionUpdated;
+    action: DraftAction<unknown, unknown>;
+}
+export interface DraftQueueStateChangedEvent {
+    type: DraftQueueEventType.QueueStateChanged;
+    state: DraftQueueState;
+}
+export type DraftQueueItemEvent = DraftQueueAddEvent | DraftQueueCompleteEvent | DraftQueueDeleteEvent | DraftQueueActionFailedEvent | DraftQueueActionUpdatedEvent;
+export type DraftQueueEvent = DraftQueueStateChangedEvent | DraftQueueItemEvent;
+export declare enum QueueOperationType {
+    Add = "add",
+    Delete = "delete",
+    Update = "update"
+}
+export interface AddQueueOperation {
+    type: QueueOperationType.Add;
+    action: DraftAction<unknown, unknown>;
+}
+export interface DeleteQueueOperation {
+    type: QueueOperationType.Delete;
+    id: string;
+}
+export interface UpdateQueueOperation {
+    type: QueueOperationType.Update;
+    id: string;
+    action: DraftAction<unknown, unknown>;
+}
+export type QueueOperation = UpdateQueueOperation | AddQueueOperation | DeleteQueueOperation;
+export interface DraftQueue {
+    /**
+     * Enqueues a draft action into the DraftQueue
+     * @param handlerId the id of the handler associated with the data
+     * @param data the data the handler will use to create the draft action with
+     * @returns A promise including the pending action created for the request
+     * @throws {Error} An error when a proper action handler is not found or conditions are not met to enqueue the action
+     */
+    enqueue<Response>(handlerId: string, data: unknown): Promise<PendingDraftAction<Response>>;
+    /**
+     * add a new handler to the draft queue to process the data in the actions
+     * @param id identifier to the handler
+     * @param handler ActionHandler to process action
+     */
+    addHandler<Data, Type>(handler: ActionHandler<Data, unknown, Type>): Promise<void>;
+    /**
+     * Creates a ActionHandler<CustomActionData> with a callback to let the DraftQueue know when it has been processed
+     * @param id identifier of the handler
+     * @param executor callback to inform DraftQueue it is complete
+     */
+    addCustomHandler(id: string, executor: CustomActionExecutor): Promise<void>;
+    /**
+     * Removes an added ActionHandler
+     * @param id identifier of the handler
+     */
+    removeHandler(id: string): Promise<void>;
+    /**
+     * Registers a listener to be notified when the Draft Queue changes
+     * @param listener Listener to notify when the draft queue changes, with an optional parameter
+     * for a completed DraftAction that triggered the change.
+     */
+    registerOnChangedListener(listener: DraftQueueChangeListener): () => Promise<void>;
+    /**
+     * Processes the next action in the draft queue
+     */
+    processNextAction(): Promise<ProcessActionResult>;
+    /**
+     * Get the current list of draft actions in queue
+     */
+    getQueueActions(): Promise<DraftAction<unknown, unknown>[]>;
+    /** The current state of the DraftQueue */
+    getQueueState(): DraftQueueState;
+    /**
+     * Removes the draft action identified by actionId from the draft queue.
+     *
+     * @param actionId The action identifier
+     */
+    removeDraftAction(actionId: string): Promise<void>;
+    /**
+     * Replaces the resource request of `withActionId` 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: string, withActionId: string): Promise<DraftAction<unknown, unknown>>;
+    /**
+     * 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.
+     */
+    mergeAction<Data, Response>(targetActionId: string, sourceActionId: string): Promise<DraftAction<Data, Response>>;
+    /** Set the draft queue state to Started and process the next item */
+    startQueue(): Promise<void>;
+    /** Set the draft queue state to Stopped and don't let another item begin */
+    stopQueue(): Promise<void>;
+    /**
+     * Sets the metadata object of the specified action to the
+     * provided metadata
+     *
+     * @param actionId The id of the draft action to set metadata on
+     * @param metadata The metadata to set on the specified action
+     */
+    setMetadata(actionId: string, metadata: DraftActionMetadata): Promise<DraftAction<unknown, unknown>>;
+    /**
+     * Gets the data associated with the passed in action. This data will have drafts applied to it
+     * @param action
+     * @returns the data for the given action or undefined if the data no longer exists
+     */
+    getDataForAction<T>(action: DraftAction<T, unknown>): Promise<T | undefined>;
+}
+export {};

package/dist/DraftStore.d.ts

@@ -0,0 +1,12 @@
+import type { DraftAction, QueueOperation } from './DraftQueue';
+import type { DraftKeyMapping } from './DraftIdMapping';
+/**
+ * Defines the store where drafts are persisted
+ */
+export interface DraftStore {
+    writeAction(action: DraftAction<unknown, unknown>): Promise<void>;
+    getAllDrafts(): Promise<DraftAction<unknown, unknown>[]>;
+    deleteDraft(actionId: string): Promise<void>;
+    deleteByTag(tag: string): Promise<void>;
+    completeAction(queueOperations: QueueOperation[], mappings: DraftKeyMapping[] | undefined): Promise<void>;
+}

package/dist/DraftSynthesisError.d.ts

@@ -0,0 +1,6 @@
+export type DraftSynthesisErrorType = 'MISSING_ID' | 'OBJECT_INFO_MISSING' | 'REFERENCED_RECORDS_MISSING' | 'UNEXPECTED_FIELDS' | 'RECORD_NOT_CACHED' | 'UNKNOWN';
+export declare class DraftSynthesisError<T> extends Error {
+    errorType: T;
+    constructor(message: string, errorType: T);
+}
+export declare function isDraftSynthesisError<T>(error: Error): error is DraftSynthesisError<T>;

package/dist/DurableDraftQueue.d.ts

@@ -0,0 +1,52 @@
+import type { DraftQueue, DraftAction, CompletedDraftAction, PendingDraftAction, DraftQueueChangeListener, DraftActionMetadata } from './DraftQueue';
+import { ProcessActionResult, DraftQueueState } from './DraftQueue';
+import type { CustomActionExecutor } from './actionHandlers/CustomActionHandler';
+import type { ActionHandler } from './actionHandlers/ActionHandler';
+import type { DraftStore } from './DraftStore';
+export declare const DRAFT_SEGMENT = "DRAFT";
+export declare class DurableDraftQueue implements DraftQueue {
+    private retryIntervalMilliseconds;
+    private minimumRetryInterval;
+    private maximumRetryInterval;
+    private draftStore;
+    private draftQueueChangedListeners;
+    private state;
+    private userState;
+    private processingAction?;
+    private replacingAction?;
+    private uploadingActionId?;
+    private timeoutHandler;
+    private handlers;
+    private getHandler;
+    constructor(draftStore: DraftStore);
+    addHandler<Data>(handler: ActionHandler<Data, unknown, unknown>): Promise<void>;
+    removeHandler(id: string): Promise<void>;
+    addCustomHandler(id: string, executor: CustomActionExecutor): Promise<void>;
+    getDataForAction<T>(action: DraftAction<T, unknown>): Promise<T | undefined>;
+    getQueueState(): DraftQueueState;
+    startQueue(): Promise<void>;
+    stopQueue(): Promise<void>;
+    /**
+     * Used to stop the queue within DraftQueue without user interaction
+     */
+    private stopQueueManually;
+    getQueueActions<Data = unknown, Response = unknown>(): Promise<DraftAction<Data, Response>[]>;
+    enqueue<Data>(handlerId: string, data: unknown): Promise<PendingDraftAction<Data>>;
+    registerOnChangedListener(listener: DraftQueueChangeListener): () => Promise<void>;
+    actionCompleted(action: CompletedDraftAction<unknown, unknown>): Promise<void>;
+    actionFailed(action: DraftAction<unknown, unknown>, retry: boolean): Promise<void>;
+    handle(action: DraftAction<unknown, unknown>): Promise<ProcessActionResult>;
+    processNextAction(): Promise<ProcessActionResult>;
+    private handleServerError;
+    private notifyChangedListeners;
+    /**
+     * only starts the queue if user state is "Started" and if queue not already
+     * started
+     */
+    private startQueueSafe;
+    removeDraftAction(actionId: string): Promise<void>;
+    replaceAction(actionId: string, withActionId: string): Promise<DraftAction<unknown, unknown>>;
+    mergeAction<Data, Response>(targetActionId: string, sourceActionId: string): Promise<DraftAction<Data, Response>>;
+    setMetadata(actionId: string, metadata: DraftActionMetadata): Promise<DraftAction<unknown, unknown>>;
+    private scheduleRetry;
+}

package/dist/DurableDraftStore.d.ts

@@ -0,0 +1,44 @@
+import type { DurableStore } from '@luvio/environments';
+import type { DraftKeyMapping } from './DraftIdMapping';
+import type { DraftAction, QueueOperation } from './DraftQueue';
+import type { DraftStore } from './DraftStore';
+/**
+ * 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.
+ *
+ */
+export declare class DurableDraftStore implements DraftStore {
+    private durableStore;
+    private draftStore;
+    private syncPromise;
+    private writeQueue;
+    constructor(durableStore: DurableStore);
+    writeAction(action: DraftAction<unknown, unknown>): Promise<void>;
+    getAllDrafts<_R, _D>(): Promise<DraftAction<unknown, unknown>[]>;
+    deleteDraft(id: string): Promise<void>;
+    deleteByTag(tag: string): Promise<void>;
+    completeAction(queueOperations: QueueOperation[], mappings: DraftKeyMapping[] | undefined): Promise<void>;
+    /**
+     * 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
+     */
+    private enqueueAction;
+    /**
+     * 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
+     */
+    private resyncDraftStore;
+    /**
+     * Runs the operations that were queued up while reviving the
+     * draft store from the durable store
+     */
+    private runQueuedOperations;
+}