@salesforce/lds-drafts 0.131.0

package/dist/types/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/types/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/types/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";
+/**
+ *
+ * @param mappingIds (optional) requested mapping ids, if undefined all will be retrieved
+ */
+export declare function getDraftIdMappings(durableStore: DurableStore, mappingIds?: string[]): Promise<DraftKeyMapping[]>;
+export declare function clearDraftIdSegment(durableStore: DurableStore): Promise<void>;

package/dist/types/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.
+     */
+    mergeActions(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/types/DraftQueue.d.ts

@@ -0,0 +1,236 @@
+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 EnqueueResult<Data, Response> {
+    action: PendingDraftAction<Data>;
+    data: Response;
+}
+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 and the data associated with the action
+     * @throws {Error} An error when a proper action handler is not found or conditions are not met to enqueue the action
+     */
+    enqueue<Data, Response>(handlerId: string, data: Data): Promise<EnqueueResult<Data, 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 targetActionId The draft action id of the target action. This action
+     * will be replaced by the source action while maintaining its position in
+     * the queue.
+     * @param sourceActionId The draft action id of the source action. This
+     * action will replace the target action and will be removed from the queue.
+     */
+    replaceAction<Data, Response>(targetActionId: string, sourceActionId: string): Promise<DraftAction<Data, Response>>;
+    /**
+     * 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<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>>;
+}
+export {};

package/dist/types/DraftStore.d.ts

@@ -0,0 +1,11 @@
+import type { DraftAction, QueueOperation } from './DraftQueue';
+/**
+ * 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[]): Promise<void>;
+}

package/dist/types/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/types/DurableDraftQueue.d.ts

@@ -0,0 +1,55 @@
+import type { DraftQueue, DraftAction, CompletedDraftAction, DraftQueueChangeListener, DraftActionMetadata, EnqueueResult } 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 workerPool;
+    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>;
+    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, Response>(handlerId: string, data: unknown): Promise<EnqueueResult<Data, Response>>;
+    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<Data, Response>(targetActionId: string, sourceActionId: string): Promise<DraftAction<Data, Response>>;
+    mergeActions<Data, Response>(targetActionId: string, sourceActionId: string): Promise<DraftAction<Data, Response>>;
+    setMetadata(actionId: string, metadata: DraftActionMetadata): Promise<DraftAction<unknown, unknown>>;
+    private scheduleRetry;
+    private getActionsForReplaceOrMerge;
+    private assertReplaceOrMergePrerequisites;
+    private replaceOrMergeActions;
+}

package/dist/types/DurableDraftStore.d.ts

@@ -0,0 +1,43 @@
+import type { DurableStore } from '@luvio/environments';
+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[]): 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;
+}

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

@@ -0,0 +1,57 @@
+import type { NetworkAdapter, ResourceRequest, Luvio, DurableStoreKeyMetadataMap } from '@luvio/engine';
+import type { DraftAction, CompletedDraftAction, QueueOperation, PendingDraftAction, DraftActionMetadata, DraftQueue, EnqueueResult } from '../DraftQueue';
+import { ProcessActionResult } from '../DraftQueue';
+import type { ActionHandler, DraftIdAndKeyMapping } from './ActionHandler';
+export type ResponseIngestionEntry<T = unknown> = {
+    response: T;
+    synchronousIngest: AbstractResourceRequestActionHandler<T, unknown>['synchronousIngest'];
+    buildCacheKeysForResponse: AbstractResourceRequestActionHandler<T, unknown>['buildCacheKeysFromResponse'];
+};
+export declare abstract class AbstractResourceRequestActionHandler<ResponseType, DraftMetadata> implements ActionHandler<ResourceRequest, DraftMetadata, ResponseType> {
+    protected readonly draftQueue: DraftQueue;
+    protected readonly networkAdapter: NetworkAdapter;
+    protected readonly getLuvio: () => Luvio;
+    ephemeralRedirects: {
+        [key: string]: string;
+    };
+    constructor(draftQueue: DraftQueue, networkAdapter: NetworkAdapter, getLuvio: () => Luvio);
+    enqueue(data: ResourceRequest): Promise<EnqueueResult<ResourceRequest, ResponseType>>;
+    handleAction(action: DraftAction<ResourceRequest, ResponseType>, actionCompleted: (action: CompletedDraftAction<ResourceRequest, ResponseType>) => Promise<void>, actionErrored: (action: DraftAction<ResourceRequest, ResponseType>, retry: boolean) => Promise<void>): Promise<ProcessActionResult>;
+    buildPendingAction(request: ResourceRequest, queue: DraftAction<unknown, unknown>[]): Promise<PendingDraftAction<ResourceRequest>>;
+    handleActionEnqueued(action: PendingDraftAction<ResourceRequest>): Promise<void>;
+    handleActionRemoved(action: DraftAction<ResourceRequest, ResponseType>): Promise<void>;
+    getQueueOperationsForCompletingDrafts(queue: DraftAction<unknown, unknown>[], action: CompletedDraftAction<ResourceRequest, ResponseType>): QueueOperation[];
+    getRedirectMappings(action: CompletedDraftAction<ResourceRequest, ResponseType>): DraftIdAndKeyMapping[] | undefined;
+    handleActionCompleted(action: CompletedDraftAction<ResourceRequest, ResponseType>, queueOperations: QueueOperation[], allHandlers: ActionHandler<unknown, unknown, unknown>[]): Promise<void>;
+    handleReplaceAction(targetAction: DraftAction<ResourceRequest, ResponseType>, sourceAction: DraftAction<ResourceRequest, ResponseType>): DraftAction<ResourceRequest, ResponseType>;
+    mergeActions(targetAction: DraftAction<ResourceRequest, ResponseType>, sourceAction: DraftAction<ResourceRequest, ResponseType>): DraftAction<ResourceRequest, ResponseType>;
+    shouldDeleteActionByTagOnRemoval(action: DraftAction<ResourceRequest, ResponseType>): boolean;
+    updateMetadata(_existingMetadata: DraftActionMetadata, incomingMetadata: DraftActionMetadata): DraftActionMetadata;
+    private isActionOfType;
+    protected reingestRecord(action: DraftAction<ResourceRequest, ResponseType>): Promise<void>;
+    getDraftIdsFromAction(action: DraftAction<ResourceRequest, ResponseType>): string[];
+    ingestResponses(responses: ResponseIngestionEntry[], action: DraftAction<ResourceRequest, ResponseType>): Promise<void>;
+    evictKey(key: string): Promise<void>;
+    abstract handlerId: string;
+    abstract canHandlePublish(key: string): boolean;
+    abstract canRepresentationContainDraftMetadata(representationName: string): boolean;
+    abstract getIdFromRequest(request: ResourceRequest): Promise<string | undefined>;
+    abstract getIdFromResponseBody(responseBody: ResponseType): string;
+    abstract buildTagForTargetId(id: string): string;
+    abstract buildCacheKeysFromResponse(response: ResponseType): DurableStoreKeyMetadataMap;
+    abstract synchronousIngest(response: ResponseType, action: DraftAction<ResourceRequest, ResponseType>): void;
+    abstract getDataForAction(action: DraftAction<ResourceRequest, ResponseType>): Promise<ResponseType | undefined>;
+    abstract getDraftMetadata(key: string): Promise<DraftMetadata | undefined>;
+    abstract applyDraftsToIncomingData(key: string, data: unknown, draftMetadata: DraftMetadata | undefined, publishFn: (key: string, data: any) => void): void;
+    /**
+     * Returns true if the given targetId is a for a draft-created record
+     *
+     * @param targetId the targetId to check
+     */
+    abstract isDraftId(targetId: string): boolean;
+    /**
+     * Overlay the sourceBody over top of the targetBody
+     */
+    abstract mergeRequestBody<T = unknown>(targetBody: T, sourceBody: T): T;
+}
+export declare function isResourceRequestAction(action: DraftAction<unknown, unknown>): action is DraftAction<ResourceRequest, unknown>;