@salesforce/lds-drafts 1.319.0 → 1.321.0

package/dist/ldsDrafts.js

@@ -100,59 +100,6 @@ 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);
@@ -349,17 +296,9 @@ function customActionHandler(executor, id, draftQueue) {
         handleActionRemoved: () => Promise.resolve(),
         handleActionCompleted: () => Promise.resolve(),
         handleActionEnqueued: () => Promise.resolve(),
-        getDataForAction: () => Promise.resolve(undefined),
-        getDraftMetadata: () => {
-            throw Error('getDraftMetadata not supported for custom actions');
-        },
-        applyDraftsToIncomingData: () => {
-            throw Error('applyDraftsToIncomingData not supported for custom actions');
-        },
+        handleActionReplaced: () => Promise.resolve(),
         shouldDeleteActionByTagOnRemoval: () => false,
         updateMetadata: (existing, incoming) => incoming,
-        canHandlePublish: () => false,
-        canRepresentationContainDraftMetadata: () => false,
         mergeActions: () => {
             throw Error('mergeActions not supported for custom actions');
         },
@@ -834,6 +773,7 @@ class DurableDraftQueue {
                     : 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,
@@ -1446,94 +1386,4 @@ function isResourceRequestAction(action) {
     return (dataAsAny !== undefined && dataAsAny.method !== undefined && dataAsAny.body !== undefined);
 }
 
-function makeEnvironmentDraftAware(luvio, env, durableStore, handlers, draftQueue) {
-    const draftMetadata = {};
-    // in 246 luvio took charge of persisting redirect mappings, this needs to stick around
-    // for a couple of releases to support older environments
-    // setup existing store redirects when bootstrapping the environment
-    (async () => {
-        const mappings = await getDraftIdMappings(durableStore);
-        mappings.forEach((mapping) => {
-            const { draftKey, canonicalKey } = mapping;
-            env.storeRedirect(draftKey, canonicalKey);
-        });
-        await env.storeBroadcast(env.rebuildSnapshot, env.snapshotAvailable);
-        await clearDraftIdSegment(durableStore);
-    })();
-    const handleSuccessResponse = async function (ingestAndBroadcastFunc, getResponseCacheKeysFunc) {
-        const queue = await draftQueue.getQueueActions();
-        if (queue.length === 0) {
-            return env.handleSuccessResponse(ingestAndBroadcastFunc, getResponseCacheKeysFunc);
-        }
-        const cacheKeySet = getResponseCacheKeysFunc();
-        for (const possibleKey of cacheKeySet.keys()) {
-            const key = typeof possibleKey === 'string' ? possibleKey : '';
-            const cacheKey = cacheKeySet.get(key);
-            for (const handler of handlers) {
-                if (cacheKey !== undefined &&
-                    handler.canRepresentationContainDraftMetadata(cacheKey.representationName)) {
-                    const metadata = await handler.getDraftMetadata(key);
-                    if (metadata !== undefined) {
-                        // if this key is related to a draft then mark it mergeable so
-                        // base environment revives it to staging store before ingestion
-                        cacheKey.mergeable = true;
-                        const existing = draftMetadata[key];
-                        if (existing === undefined) {
-                            draftMetadata[key] = { metadata, refCount: 1 };
-                        }
-                        else {
-                            draftMetadata[key] = { metadata, refCount: existing.refCount + 1 };
-                        }
-                    }
-                    break;
-                }
-            }
-        }
-        return env.handleSuccessResponse(ingestAndBroadcastFunc, () => cacheKeySet);
-    };
-    const storePublish = function (key, data) {
-        const draftMetadataForKey = draftMetadata[key];
-        let handled = false;
-        for (const handler of handlers) {
-            if (handler.canHandlePublish(key)) {
-                handled = true;
-                handler.applyDraftsToIncomingData(key, data, draftMetadataForKey && draftMetadataForKey.metadata, env.storePublish);
-                // deletes the draft metadata once it is published and has 0 ref.
-                if (draftMetadataForKey &&
-                    draftMetadataForKey.metadata &&
-                    draftMetadataForKey.refCount === 0) {
-                    delete draftMetadata[key];
-                }
-                break;
-            }
-        }
-        decrementRefCount(key);
-        // no handler could handle it so publish
-        if (!handled) {
-            env.storePublish(key, data);
-        }
-    };
-    const decrementRefCount = function (key) {
-        const draftMetadataForKey = draftMetadata[key];
-        if (draftMetadataForKey !== undefined) {
-            // metadata is needed for a once-draft record to create ref link for spanning fields.
-            if (draftMetadataForKey.refCount === 1) {
-                draftMetadata[key].metadata.recordOperations = [];
-            }
-            draftMetadataForKey.refCount--;
-        }
-    };
-    // when a record is soft deleted it won't be published so won't decrement the ref count
-    // this is a backdoor to decrement the ref count
-    const softEvict = function (key) {
-        decrementRefCount(key);
-    };
-    // note the makeEnvironmentUiApiRecordDraftAware will eventually go away once the adapters become draft aware
-    return create(env, {
-        storePublish: { value: storePublish },
-        handleSuccessResponse: { value: handleSuccessResponse },
-        softEvict: { value: softEvict },
-    });
-}
-
-export { CustomActionResultType, DRAFT_ERROR_CODE, DRAFT_ID_MAPPINGS_SEGMENT, DRAFT_SEGMENT, DraftActionOperationType, DraftActionStatus, DraftErrorFetchResponse, DraftFetchResponse, DraftManager, DraftQueueEventType, DraftQueueState, DraftSynthesisError, DurableDraftQueue, DurableDraftStore, ProcessActionResult, QueueOperationType, createBadRequestResponse, createDeletedResponse, createDraftSynthesisErrorResponse, createInternalErrorResponse, createNotFoundResponse, createOkResponse, generateUniqueDraftActionId, isDraftSynthesisError, makeEnvironmentDraftAware, transformErrorToDraftSynthesisError };
+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 };

package/dist/types/DraftQueue.d.ts

@@ -171,7 +171,7 @@ export interface DraftQueue {
      * @param id identifier to the handler
      * @param handler ActionHandler to process action
      */
-    addHandler<Data, Type>(handler: ActionHandler<Data, unknown, Type>): Promise<void>;
+    addHandler<Data, Type>(handler: ActionHandler<Data, 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

package/dist/types/DurableDraftQueue.d.ts

@@ -21,7 +21,7 @@ export declare class DurableDraftQueue implements DraftQueue {
     private handlers;
     private getHandler;
     constructor(draftStore: DraftStore);
-    addHandler<Data>(handler: ActionHandler<Data, unknown, unknown>): Promise<void>;
+    addHandler<Data>(handler: ActionHandler<Data, unknown>): Promise<void>;
     removeHandler(id: string): Promise<void>;
     addCustomHandler(id: string, executor: CustomActionExecutor): Promise<void>;
     getQueueState(): DraftQueueState;

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

@@ -1,14 +1,9 @@
 import type { CompletedDraftAction, DraftAction, DraftActionMetadata, PendingDraftAction, ProcessActionResult, QueueOperation } from '../DraftQueue';
-import type { DraftKeyMapping } from '../DraftIdMapping';
 export interface ReplacingActions<Response, Data> {
     original: DraftAction<Response, Data>;
     actionToReplace: DraftAction<Response, Data>;
     replacingAction: DraftAction<Response, Data>;
 }
-export interface DraftIdAndKeyMapping extends DraftKeyMapping {
-    draftId: string;
-    canonicalId: string;
-}
 /**
  * A Handler that knows what the Data and Response type expected are in a DraftAction.
  * It knows how to process and set them up.
@@ -16,22 +11,12 @@ export interface DraftIdAndKeyMapping extends DraftKeyMapping {
  * The action handler is registered both with the DraftQueue and the Draft environment to handle
  * all draft application logic to a particular type
  */
-export interface ActionHandler<Data, DraftMetadata, Type> {
+export interface ActionHandler<Data, Type> {
     /**
      * The id for this handler. Every action in the queue will have a handlerId property
      * associated with it which specifies which handler knows how to handle that draft action
      */
     handlerId: string;
-    /**
-     * Invoked by the draft environment while ingesting incoming data to determine if the handler knows how to apply drafts to the incoming key
-     * @param key
-     */
-    canHandlePublish(key: string): boolean;
-    /**
-     * Invoked by the draft environment prior to ingesting to determine if the representation type can potentially have draft metadata
-     * @param representationName
-     */
-    canRepresentationContainDraftMetadata(representationName: string): boolean;
     /**
      * Enqueues an action to the draft queue
      * @param data the data that will get added to the draft action
@@ -77,7 +62,7 @@ export interface ActionHandler<Data, DraftMetadata, Type> {
      * @param action The completed action
      * @param queueOperations The queue modification operations that were executes with the completed action
      */
-    handleActionCompleted(action: CompletedDraftAction<Data, Type>, queueOperations: QueueOperation[], allHandlers: ActionHandler<unknown, unknown, unknown>[]): Promise<void>;
+    handleActionCompleted(action: CompletedDraftAction<Data, Type>, queueOperations: QueueOperation[], allHandlers: ActionHandler<unknown, unknown>[]): Promise<void>;
     /**
      * Replace the targetAction's data with the sourceAction's data and return
      * the targetAction.  Also sets the targetAction's status to Pending.
@@ -92,32 +77,6 @@ export interface ActionHandler<Data, DraftMetadata, Type> {
      * in an error.
      */
     handleReplaceAction(targetAction: DraftAction<Data, Type>, sourceAction: DraftAction<Data, Type>): DraftAction<Data, Type>;
-    /**
-     * Invoked by the durable store and the draft environment to get the data that is associated with this draft action
-     * The data should include all drafts applied to it (if any)
-     * @param action The action to get data for
-     * @param queue The draft queue
-     *
-     * @returns the data with the up to date draft changes applied. returns undefined if after replaying drafts there is no
-     * data to return (i.e. a draft-created record had it's post action removed)
-     */
-    getDataForAction(action: DraftAction<Data, Type>): Promise<Type | undefined>;
-    /**
-     * Asynchronous function to fetch any necessary metadata required to apply drafts during ingest
-     * Note that since ingest is synchronous any necessary metadata that requires asynchronicity must be fetch prior to ingest commencing
-     * @param key
-     * @returns the metadata or undefined if there's no drafts associated or no metadata for this key
-     */
-    getDraftMetadata(key: string): Promise<DraftMetadata | undefined>;
-    /**
-     * Invoked by the draft environment while ingesting normalized data that may contain drafts.
-     * Note that this function is synchronous since ingestion is synchronous (see note in getDraftMetadata)
-     * @param key The key being ingested
-     * @param data The normalized data being ingested
-     * @param draftMetadata The metadata that was previously fetched using getDraftMetadata
-     * @param publishFn The environment's publish method to publish the data once drafts have been applied
-     */
-    applyDraftsToIncomingData(key: string, data: unknown, draftMetadata: DraftMetadata | undefined, publishFn: (key: string, data: any) => void): void;
     /**
      * Invoked by the draft queue when a request to remove an action is made. This tells the queue whether it should just
      * delete the requested action or any action with the same tag. This is helpful in examples where other related queue items no longer
@@ -145,4 +104,9 @@ export interface ActionHandler<Data, DraftMetadata, Type> {
      * NOTE: the resulting merged action will use the target's timestamp and id.
      */
     mergeActions(targetAction: DraftAction<Data, Type>, sourceAction: DraftAction<Data, Type>): DraftAction<Data, Type>;
+    /**
+     * Invoked when an action is replaced
+     * @param action
+     */
+    handleActionReplaced(target: DraftAction<Data, Type>, source: DraftAction<Data, Type>): Promise<void>;
 }

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

@@ -29,5 +29,5 @@ export type CustomActionCompletionResponse = (result: CustomActionResult) => voi
 export interface CustomActionData {
     [key: string]: string;
 }
-export declare function customActionHandler(executor: CustomActionExecutor, id: string, draftQueue: DraftQueue): ActionHandler<CustomActionData, unknown, unknown>;
+export declare function customActionHandler(executor: CustomActionExecutor, id: string, draftQueue: DraftQueue): ActionHandler<CustomActionData, unknown>;
 export {};

package/dist/types/main.d.ts

@@ -1,15 +1,12 @@
 export { DraftQueue, DraftQueueState, DraftAction, ErrorDraftAction, PendingDraftAction, CompletedDraftAction, DraftActionStatus, ProcessActionResult, DraftQueueChangeListener, DraftActionMetadata, DraftQueueEventType, QueueOperation, UpdateQueueOperation, QueueOperationType, } from './DraftQueue';
-export { DRAFT_ID_MAPPINGS_SEGMENT, DraftKeyMapping } from './DraftIdMapping';
 export { DurableDraftQueue, DRAFT_SEGMENT } from './DurableDraftQueue';
 export { generateUniqueDraftActionId, uuidv4 } from './utils/id';
 export { DurableDraftStore } from './DurableDraftStore';
 export { DraftStore } from './DraftStore';
 export { DraftManager, DraftManagerState, DraftActionOperationType, DraftQueueItem, DraftQueueItemMetadata, } from './DraftManager';
-export { ActionHandler, ReplacingActions, DraftIdAndKeyMapping, } from './actionHandlers/ActionHandler';
+export { ActionHandler, ReplacingActions } from './actionHandlers/ActionHandler';
 export type { CustomActionResult } from './actionHandlers/CustomActionHandler';
 export { CustomActionResultType, CustomActionExecutor } from './actionHandlers/CustomActionHandler';
-export { makeEnvironmentDraftAware } from './makeEnvironmentDraftAware';
-export type { DraftAwareEnvironment } from './makeEnvironmentDraftAware';
 export * from './DraftFetchResponse';
 export { DraftSynthesisErrorType, DraftSynthesisError, isDraftSynthesisError, } from './DraftSynthesisError';
 export { transformErrorToDraftSynthesisError } from './DraftFetchResponse';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-drafts",
-    "version": "1.319.0",
+    "version": "1.321.0",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "LDS Drafts",
     "main": "dist/ldsDrafts.js",
@@ -24,12 +24,12 @@
         "release:corejar": "yarn build && ../core-build/scripts/core.js --adapter=lds-drafts"
     },
     "dependencies": {
-        "@luvio/engine": "0.156.4",
-        "@luvio/environments": "0.156.4",
-        "@salesforce/lds-utils-adapters": "^1.319.0"
+        "@luvio/engine": "0.156.5",
+        "@luvio/environments": "0.156.5",
+        "@salesforce/lds-utils-adapters": "^1.321.0"
     },
     "devDependencies": {
-        "@salesforce/nimbus-plugin-lds": "^1.319.0"
+        "@salesforce/nimbus-plugin-lds": "^1.321.0"
     },
     "volta": {
         "extends": "../../package.json"

package/dist/types/DraftIdMapping.d.ts

@@ -1,12 +0,0 @@
-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/makeEnvironmentDraftAware.d.ts

@@ -1,7 +0,0 @@
-import type { Luvio, ResourceRequest } from '@luvio/engine';
-import type { DurableEnvironment, DurableStore } from '@luvio/environments';
-import type { ActionHandler, DraftQueue } from './main';
-export interface DraftAwareEnvironment extends DurableEnvironment {
-    softEvict: (key: string) => void;
-}
-export declare function makeEnvironmentDraftAware(luvio: Luvio, env: DurableEnvironment, durableStore: DurableStore, handlers: ActionHandler<ResourceRequest, any, any>[], draftQueue: DraftQueue): DraftAwareEnvironment;