@salesforce/lds-drafts 1.313.0 → 1.314.0

package/dist/ldsDrafts.js

@@ -5,7 +5,7 @@
  */
 
 import { HttpStatusCode, StoreKeyMap } from '@luvio/engine';
-import { uuidv4, AsyncWorkerPool } from '@salesforce/lds-utils-adapters';
+import { AsyncWorkerPool, uuidv4 } from '@salesforce/lds-utils-adapters';
 import ldsIdempotencyWriteDisabled from '@salesforce/gate/lds.idempotencyWriteDisabled';
 import ldsBackdatingEnabled from '@salesforce/gate/lds.backdatingEnabled';
 
@@ -97,6 +97,63 @@ var QueueOperationType;
     QueueOperationType["Update"] = "update";
 })(QueueOperationType || (QueueOperationType = {}));
 
+const { keys, create, assign, values } = Object;
+const { stringify, parse } = JSON;
+const { isArray } = Array;
+
+const DraftIdMappingKeyPrefix240 = 'DraftIdMapping::';
+const DRAFT_ID_MAPPINGS_SEGMENT = 'DRAFT_ID_MAPPINGS';
+function isLegacyDraftIdMapping(key, data) {
+    return key.startsWith(DraftIdMappingKeyPrefix240);
+}
+// TODO [W-11677776]: in 242 we changed the format to store keys instead of ids
+// this can be removed when we drop support for id storing
+function getRecordKeyForId(id) {
+    return `UiApi::RecordRepresentation:${id}`;
+}
+/**
+ *
+ * @param mappingIds (optional) requested mapping ids, if undefined all will be retrieved
+ */
+async function getDraftIdMappings(durableStore, mappingIds) {
+    const mappings = [];
+    let durableStoreOperation;
+    if (mappingIds === undefined) {
+        durableStoreOperation =
+            durableStore.getAllEntries(DRAFT_ID_MAPPINGS_SEGMENT);
+    }
+    else {
+        durableStoreOperation = durableStore.getEntries(mappingIds, DRAFT_ID_MAPPINGS_SEGMENT);
+    }
+    const entries = await durableStoreOperation;
+    if (entries === undefined) {
+        return mappings;
+    }
+    const keys$1 = keys(entries);
+    for (const key of keys$1) {
+        const entry = entries[key].data;
+        if (isLegacyDraftIdMapping(key)) {
+            mappings.push({
+                draftKey: getRecordKeyForId(entry.draftId),
+                canonicalKey: getRecordKeyForId(entry.canonicalId),
+            });
+        }
+        else {
+            mappings.push(entry);
+        }
+    }
+    return mappings;
+}
+async function clearDraftIdSegment(durableStore) {
+    const entries = await durableStore.getAllEntries(DRAFT_ID_MAPPINGS_SEGMENT);
+    if (entries) {
+        const keys$1 = keys(entries);
+        if (keys$1.length > 0) {
+            await durableStore.evictEntries(keys$1, DRAFT_ID_MAPPINGS_SEGMENT);
+        }
+    }
+}
+
 class DraftSynthesisError extends Error {
     constructor(message, errorType) {
         super(message);
@@ -190,14 +247,6 @@ function createInternalErrorResponse() {
     return new DraftErrorFetchResponse(HttpStatusCode.ServerError, undefined);
 }
 
-const { keys, create, assign, values } = Object;
-const { stringify, parse } = JSON;
-const { isArray } = Array;
-
-function clone(obj) {
-    return parse(stringify(obj));
-}
-
 /**
  * Generates a time-ordered, unique id to associate with a DraftAction. Ensures
  * no collisions with existing draft action IDs.
@@ -222,125 +271,6 @@ function generateUniqueDraftActionId(existingIds) {
     return newId.toString();
 }
 
-const HTTP_HEADER_RETRY_AFTER = 'Retry-After';
-const HTTP_HEADER_IDEMPOTENCY_KEY = 'Idempotency-Key';
-const ERROR_CODE_IDEMPOTENCY_FEATURE_NOT_ENABLED = 'IDEMPOTENCY_FEATURE_NOT_ENABLED';
-const ERROR_CODE_IDEMPOTENCY_NOT_SUPPORTED = 'IDEMPOTENCY_NOT_SUPPORTED';
-const ERROR_CODE_IDEMPOTENCY_KEY_USED_DIFFERENT_USER = 'IDEMPOTENCY_KEY_USED_DIFFERENT_USER';
-const ERROR_CODE_IDEMPOTENCY_CONCURRENT_REQUEST = 'IDEMPOTENCY_CONCURRENT_REQUEST';
-const ERROR_CODE_IDEMPOTENCY_KEY_ALREADY_USED = 'IDEMPOTENCY_KEY_ALREADY_USED';
-const ERROR_CODE_IDEMPOTENCY_BACKEND_OPERATION_ERROR = 'IDEMPOTENCY_BACKEND_OPERATION_ERROR';
-/**
- * Get the retry after in milliseconds from the response headers, undefined if not specified.
- * The header could have two different format.
- * Retry-After: <http-date>, like Wed, 21 Oct 2015 07:28:00 GMT
- * Retry-After: <delay-seconds>, like 1.5s
- * @param headers http headers
- * @returns the time to delat in millisconds.
- */
-function getRetryAfterInMs(headers) {
-    const retryAfterHeader = headers && headers[HTTP_HEADER_RETRY_AFTER];
-    if (retryAfterHeader === undefined) {
-        return undefined;
-    }
-    const delayInSecond = parseFloat(retryAfterHeader);
-    if (retryAfterHeader === delayInSecond.toString()) {
-        return Math.round(delayInSecond * 1000);
-    }
-    const delayUntilDateTime = Date.parse(retryAfterHeader);
-    if (isNaN(delayUntilDateTime)) {
-        return undefined;
-    }
-    return delayUntilDateTime - Date.now();
-}
-
-function buildLuvioOverrideForDraftAdapters(luvio, handler, extractTargetIdFromCacheKey) {
-    // override this to create and enqueue a new draft action, and return synthetic response
-    const dispatchResourceRequest = async function (resourceRequest, _context) {
-        const resourceRequestCopy = clone(resourceRequest);
-        resourceRequestCopy.headers = resourceRequestCopy.headers || {};
-        if (handler.hasIdempotencySupport()) {
-            resourceRequestCopy.headers[HTTP_HEADER_IDEMPOTENCY_KEY] = uuidv4();
-        }
-        const { data } = await handler.enqueue(resourceRequestCopy).catch((err) => {
-            throw transformErrorToDraftSynthesisError(err);
-        });
-        if (data === undefined) {
-            return Promise.reject(createDraftSynthesisErrorResponse());
-        }
-        return createOkResponse(data);
-    };
-    // override this to use an infinitely large ttl so the cache entry never expires
-    const publishStoreMetadata = function (key, storeMetadataParams) {
-        // if we aren't publishing a draft then use base luvio method
-        const id = extractTargetIdFromCacheKey(key);
-        if (id === undefined || !handler.isDraftId(id)) {
-            return luvio.publishStoreMetadata(key, storeMetadataParams);
-        }
-        return luvio.publishStoreMetadata(key, {
-            ...storeMetadataParams,
-            ttl: Number.MAX_SAFE_INTEGER,
-        });
-    };
-    return create(luvio, {
-        dispatchResourceRequest: { value: dispatchResourceRequest },
-        publishStoreMetadata: { value: publishStoreMetadata },
-    });
-}
-
-const DraftIdMappingKeyPrefix240 = 'DraftIdMapping::';
-const DRAFT_ID_MAPPINGS_SEGMENT = 'DRAFT_ID_MAPPINGS';
-function isLegacyDraftIdMapping(key, data) {
-    return key.startsWith(DraftIdMappingKeyPrefix240);
-}
-// TODO [W-11677776]: in 242 we changed the format to store keys instead of ids
-// this can be removed when we drop support for id storing
-function getRecordKeyForId(id) {
-    return `UiApi::RecordRepresentation:${id}`;
-}
-/**
- *
- * @param mappingIds (optional) requested mapping ids, if undefined all will be retrieved
- */
-async function getDraftIdMappings(durableStore, mappingIds) {
-    const mappings = [];
-    let durableStoreOperation;
-    if (mappingIds === undefined) {
-        durableStoreOperation =
-            durableStore.getAllEntries(DRAFT_ID_MAPPINGS_SEGMENT);
-    }
-    else {
-        durableStoreOperation = durableStore.getEntries(mappingIds, DRAFT_ID_MAPPINGS_SEGMENT);
-    }
-    const entries = await durableStoreOperation;
-    if (entries === undefined) {
-        return mappings;
-    }
-    const keys$1 = keys(entries);
-    for (const key of keys$1) {
-        const entry = entries[key].data;
-        if (isLegacyDraftIdMapping(key)) {
-            mappings.push({
-                draftKey: getRecordKeyForId(entry.draftId),
-                canonicalKey: getRecordKeyForId(entry.canonicalId),
-            });
-        }
-        else {
-            mappings.push(entry);
-        }
-    }
-    return mappings;
-}
-async function clearDraftIdSegment(durableStore) {
-    const entries = await durableStore.getAllEntries(DRAFT_ID_MAPPINGS_SEGMENT);
-    if (entries) {
-        const keys$1 = keys(entries);
-        if (keys$1.length > 0) {
-            await durableStore.evictEntries(keys$1, DRAFT_ID_MAPPINGS_SEGMENT);
-        }
-    }
-}
-
 var CustomActionResultType;
 (function (CustomActionResultType) {
     CustomActionResultType["SUCCESS"] = "SUCCESS";
@@ -568,11 +498,7 @@ class DurableDraftQueue {
                 if (this.state === DraftQueueState.Started) {
                     this.processNextAction();
                 }
-                const actionData = (await handler.getDataForAction(pendingAction));
-                return {
-                    action: pendingAction,
-                    data: actionData,
-                };
+                return pendingAction;
             },
         });
     }
@@ -914,6 +840,10 @@ class DurableDraftQueue {
     }
 }
 
+function clone(obj) {
+    return parse(stringify(obj));
+}
+
 const DRAFT_ACTION_KEY_JUNCTION = '__DraftAction__';
 function buildDraftDurableStoreKey(recordKey, draftActionId) {
     return `${recordKey}${DRAFT_ACTION_KEY_JUNCTION}${draftActionId}`;
@@ -1123,6 +1053,38 @@ class DurableDraftStore {
     }
 }
 
+const HTTP_HEADER_RETRY_AFTER = 'Retry-After';
+const HTTP_HEADER_IDEMPOTENCY_KEY = 'Idempotency-Key';
+const ERROR_CODE_IDEMPOTENCY_FEATURE_NOT_ENABLED = 'IDEMPOTENCY_FEATURE_NOT_ENABLED';
+const ERROR_CODE_IDEMPOTENCY_NOT_SUPPORTED = 'IDEMPOTENCY_NOT_SUPPORTED';
+const ERROR_CODE_IDEMPOTENCY_KEY_USED_DIFFERENT_USER = 'IDEMPOTENCY_KEY_USED_DIFFERENT_USER';
+const ERROR_CODE_IDEMPOTENCY_CONCURRENT_REQUEST = 'IDEMPOTENCY_CONCURRENT_REQUEST';
+const ERROR_CODE_IDEMPOTENCY_KEY_ALREADY_USED = 'IDEMPOTENCY_KEY_ALREADY_USED';
+const ERROR_CODE_IDEMPOTENCY_BACKEND_OPERATION_ERROR = 'IDEMPOTENCY_BACKEND_OPERATION_ERROR';
+/**
+ * Get the retry after in milliseconds from the response headers, undefined if not specified.
+ * The header could have two different format.
+ * Retry-After: <http-date>, like Wed, 21 Oct 2015 07:28:00 GMT
+ * Retry-After: <delay-seconds>, like 1.5s
+ * @param headers http headers
+ * @returns the time to delat in millisconds.
+ */
+function getRetryAfterInMs(headers) {
+    const retryAfterHeader = headers && headers[HTTP_HEADER_RETRY_AFTER];
+    if (retryAfterHeader === undefined) {
+        return undefined;
+    }
+    const delayInSecond = parseFloat(retryAfterHeader);
+    if (retryAfterHeader === delayInSecond.toString()) {
+        return Math.round(delayInSecond * 1000);
+    }
+    const delayUntilDateTime = Date.parse(retryAfterHeader);
+    if (isNaN(delayUntilDateTime)) {
+        return undefined;
+    }
+    return delayUntilDateTime - Date.now();
+}
+
 const DEFAULT_FIELD_LAST_MODIFIED_DATE = 'LastModifiedDate';
 const DEFAULT_FIELD_CREATED_DATE = 'CreatedDate';
 class AbstractResourceRequestActionHandler {
@@ -1721,7 +1683,7 @@ class DraftManager {
             tag,
         })
             .then((result) => {
-            return this.buildDraftQueueItem(result.action);
+            return this.buildDraftQueueItem(result);
         });
     }
     /**
@@ -2043,4 +2005,4 @@ function makeEnvironmentDraftAware(luvio, env, durableStore, handlers, draftQueu
     });
 }
 
-export { AbstractResourceRequestActionHandler, CustomActionResultType, DEFAULT_FIELD_CREATED_DATE, DEFAULT_FIELD_LAST_MODIFIED_DATE, DRAFT_ERROR_CODE, DRAFT_ID_MAPPINGS_SEGMENT, DRAFT_SEGMENT, DraftActionOperationType, DraftActionStatus, DraftErrorFetchResponse, DraftFetchResponse, DraftManager, DraftQueueEventType, DraftQueueState, DraftSynthesisError, DurableDraftQueue, DurableDraftStore, ProcessActionResult, buildLuvioOverrideForDraftAdapters, createBadRequestResponse, createDeletedResponse, createDraftSynthesisErrorResponse, createInternalErrorResponse, createNotFoundResponse, createOkResponse, generateUniqueDraftActionId, isDraftSynthesisError, makeEnvironmentDraftAware, transformErrorToDraftSynthesisError };
+export { AbstractResourceRequestActionHandler, CustomActionResultType, DEFAULT_FIELD_CREATED_DATE, DEFAULT_FIELD_LAST_MODIFIED_DATE, DRAFT_ERROR_CODE, DRAFT_ID_MAPPINGS_SEGMENT, DRAFT_SEGMENT, DraftActionOperationType, DraftActionStatus, DraftErrorFetchResponse, DraftFetchResponse, DraftManager, DraftQueueEventType, DraftQueueState, DraftSynthesisError, DurableDraftQueue, DurableDraftStore, ProcessActionResult, createBadRequestResponse, createDeletedResponse, createDraftSynthesisErrorResponse, createInternalErrorResponse, createNotFoundResponse, createOkResponse, generateUniqueDraftActionId, isDraftSynthesisError, makeEnvironmentDraftAware, transformErrorToDraftSynthesisError };

package/dist/types/DraftQueue.d.ts

@@ -152,10 +152,6 @@ export interface UpdateQueueOperation {
     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
@@ -164,7 +160,7 @@ export interface DraftQueue {
      * @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>>;
+    enqueue<Data>(handlerId: string, data: Data): Promise<PendingDraftAction<Data>>;
     /**
      * add a new handler to the draft queue to process the data in the actions
      * @param id identifier to the handler

package/dist/types/DurableDraftQueue.d.ts

@@ -1,4 +1,4 @@
-import type { DraftQueue, DraftAction, CompletedDraftAction, PendingDraftAction, DraftQueueChangeListener, DraftActionMetadata, EnqueueResult } from './DraftQueue';
+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';
@@ -31,7 +31,7 @@ export declare class DurableDraftQueue implements DraftQueue {
      */
     private stopQueueManually;
     getQueueActions<Data = unknown, Response = unknown>(): Promise<DraftAction<Data, Response>[]>;
-    enqueue<Data, Response>(handlerId: string, data: unknown): Promise<EnqueueResult<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, retryDelayInMs?: number, actionDataChanged?: boolean): Promise<void>;

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

@@ -1,5 +1,5 @@
 import type { NetworkAdapter, ResourceRequest, Luvio, DurableStoreKeyMetadataMap } from '@luvio/engine';
-import type { DraftAction, CompletedDraftAction, QueueOperation, PendingDraftAction, DraftActionMetadata, DraftQueue, EnqueueResult } from '../DraftQueue';
+import type { DraftAction, CompletedDraftAction, QueueOperation, PendingDraftAction, DraftActionMetadata, DraftQueue } from '../DraftQueue';
 import { ProcessActionResult } from '../DraftQueue';
 import type { ActionHandler, DraftIdAndKeyMapping } from './ActionHandler';
 export type ResponseIngestionEntry<T = unknown> = {
@@ -20,7 +20,7 @@ export declare abstract class AbstractResourceRequestActionHandler<ResponseType,
     isLdsIdempotencyWriteDisabled: boolean;
     isBackdatingEnabled: boolean;
     constructor(draftQueue: DraftQueue, networkAdapter: NetworkAdapter, getLuvio: () => Luvio);
-    enqueue(data: ResourceRequest): Promise<EnqueueResult<ResourceRequest, ResponseType>>;
+    enqueue(data: ResourceRequest): Promise<PendingDraftAction<ResourceRequest>>;
     handleAction(action: DraftAction<ResourceRequest, ResponseType>, actionCompleted: (action: CompletedDraftAction<ResourceRequest, ResponseType>) => Promise<void>, actionErrored: (action: DraftAction<ResourceRequest, ResponseType>, retry: boolean, retryDelayInMs?: number, actionDataChanged?: boolean) => Promise<void>): Promise<ProcessActionResult>;
     handleIdempotencyServerError(responseBody: any, action: DraftAction<ResourceRequest, ResponseType>, updateIdempotencyKey: boolean, ...targetErrorCodes: string[]): boolean;
     isUiApiErrors(body: any): boolean;

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

@@ -1,4 +1,4 @@
-import type { CompletedDraftAction, DraftAction, DraftActionMetadata, EnqueueResult, PendingDraftAction, ProcessActionResult, QueueOperation } from '../DraftQueue';
+import type { CompletedDraftAction, DraftAction, DraftActionMetadata, PendingDraftAction, ProcessActionResult, QueueOperation } from '../DraftQueue';
 import type { DraftKeyMapping } from '../DraftIdMapping';
 export interface ReplacingActions<Response, Data> {
     original: DraftAction<Response, Data>;
@@ -36,7 +36,7 @@ export interface ActionHandler<Data, DraftMetadata, Type> {
      * Enqueues an action to the draft queue
      * @param data the data that will get added to the draft action
      */
-    enqueue(data: Data): Promise<EnqueueResult<Data, Type>>;
+    enqueue(data: Data): Promise<PendingDraftAction<Data>>;
     /**
      * Used to build a PendingDraftAction that is specific to the type of Data and Response.
      * @param data

package/dist/types/main.d.ts

@@ -1,5 +1,4 @@
 export { DraftQueue, DraftQueueState, DraftAction, ErrorDraftAction, PendingDraftAction, CompletedDraftAction, DraftActionStatus, ProcessActionResult, DraftQueueChangeListener, DraftActionMetadata, DraftQueueEventType, QueueOperation, } from './DraftQueue';
-export { AdapterBuildNetworkSnapshot, buildLuvioOverrideForDraftAdapters, } from './DraftAwareAdapter';
 export { DRAFT_ID_MAPPINGS_SEGMENT, DraftKeyMapping } from './DraftIdMapping';
 export { DurableDraftQueue, DRAFT_SEGMENT } from './DurableDraftQueue';
 export { generateUniqueDraftActionId } from './utils/id';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-drafts",
-    "version": "1.313.0",
+    "version": "1.314.0",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "LDS Drafts",
     "main": "dist/ldsDrafts.js",
@@ -26,7 +26,7 @@
     "dependencies": {
         "@luvio/engine": "0.156.4",
         "@luvio/environments": "0.156.4",
-        "@salesforce/lds-utils-adapters": "^1.313.0"
+        "@salesforce/lds-utils-adapters": "^1.314.0"
     },
     "volta": {
         "extends": "../../package.json"

package/dist/types/DraftAwareAdapter.d.ts

@@ -1,4 +0,0 @@
-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): Luvio;