@salesforce/lds-drafts 1.451.0 → 1.453.0

package/dist/ldsDrafts.js

@@ -322,7 +322,7 @@ class DurableDraftQueue {
         }
         return handler;
     }
-    constructor(draftStore) {
+    constructor(draftStore, instrumentation) {
         this.retryIntervalMilliseconds = 0;
         this.minimumRetryInterval = 250;
         this.maximumRetryInterval = 32000;
@@ -339,6 +339,7 @@ class DurableDraftQueue {
         this.handlers = {};
         this.draftStore = draftStore;
         this.workerPool = new AsyncWorkerPool(1);
+        this.instrumentation = instrumentation;
     }
     addHandler(handler) {
         const id = handler.handlerId;
@@ -429,15 +430,22 @@ class DurableDraftQueue {
         this.state = DraftQueueState.Stopped;
     }
     async getQueueActions() {
+        // W-23515682: time the whole call, including this queue's own internal
+        // this.getQueueActions() during a drain — the amplification signal an external wrapper
+        // cannot see. Measure-only; control flow below is unchanged.
+        const { instrumentation } = this;
+        const start = instrumentation?.onGetQueueActions !== undefined ? Date.now() : 0;
         const drafts = (await this.draftStore.getAllDrafts());
         const queue = [];
         drafts.forEach((draft) => {
             if (draft.id === this.uploadingActionId) {
-                draft.status = DraftActionStatus.Uploading;
+                queue.push({ ...draft, status: DraftActionStatus.Uploading });
+            }
+            else {
+                queue.push(draft);
             }
-            queue.push(draft);
         });
-        return queue.sort((a, b) => {
+        const sorted = queue.sort((a, b) => {
             const aTime = parseInt(a.id, 10);
             const bTime = parseInt(b.id, 10);
             // safety check
@@ -449,6 +457,8 @@ class DurableDraftQueue {
             }
             return aTime - bTime;
         });
+        instrumentation?.onGetQueueActions?.(Date.now() - start, sorted.length);
+        return sorted;
     }
     async enqueue(handlerId, data, observabilityContext) {
         return this.workerPool.push({
@@ -597,6 +607,8 @@ class DurableDraftQueue {
             const listener = draftQueueChangedListeners[i];
             results.push(listener(event));
         }
+        // W-23515682: listener fan-out per event type. Measure-only.
+        this.instrumentation?.onNotifyChangedListeners?.(event.type, draftQueueLen);
         await Promise.all(results);
     }
     /**
@@ -844,36 +856,66 @@ function buildDraftDurableStoreKey(recordKey, draftActionId) {
  *
  */
 class DurableDraftStore {
-    constructor(durableStore) {
+    constructor(durableStore, instrumentation, useSnapshot = true) {
         this.draftStore = {};
+        // Snapshot: holds deep clones of each draft, refreshed at write time.
+        // getAllDrafts serves from this snapshot with zero deep clones per read.
+        this.cleanSnapshot = {};
         // queue of writes that were made during the initial sync
         this.writeQueue = [];
         this.durableStore = durableStore;
+        this.instrumentation = instrumentation;
+        this.useSnapshot = useSnapshot;
         this.resyncDraftStore();
     }
+    // When no instrumentation is injected the promise is returned as-is (zero overhead).
+    timeDurableOp(op, segment, run) {
+        const onDurableOperation = this.instrumentation?.onDurableOperation;
+        if (onDurableOperation === undefined) {
+            return run();
+        }
+        const start = Date.now();
+        return run().finally(() => {
+            onDurableOperation(op, segment, Date.now() - start);
+        });
+    }
     writeAction(action) {
         const addAction = () => {
             const { id, tag } = action;
             this.draftStore[id] = action;
+            this.cleanSnapshot[id] = clone(action);
             const durableEntryKey = buildDraftDurableStoreKey(tag, id);
             const entry = {
                 data: action,
             };
             const entries = { [durableEntryKey]: entry };
-            return this.durableStore.setEntries(entries, DRAFT_SEGMENT);
+            return this.timeDurableOp('setEntries', DRAFT_SEGMENT, () => this.durableStore.setEntries(entries, DRAFT_SEGMENT));
         };
         return this.enqueueAction(addAction);
     }
     getAllDrafts() {
         const waitForOngoingSync = this.syncPromise || Promise.resolve();
         return waitForOngoingSync.then(() => {
-            const { draftStore } = this;
-            const keys$1 = keys(draftStore);
             const actionArray = [];
-            for (let i = 0, len = keys$1.length; i < len; i++) {
-                const key = keys$1[i];
-                // clone draft so we don't expose the internal draft store
-                actionArray.push(clone(draftStore[key]));
+            if (this.useSnapshot) {
+                const { cleanSnapshot } = this;
+                const keys$1 = keys(cleanSnapshot);
+                for (let i = 0, len = keys$1.length; i < len; i++) {
+                    const key = keys$1[i];
+                    // Return shallow spread of snapshot entries so top-level caller mutations
+                    // (e.g., .status =) don't persist into the snapshot. The snapshot itself
+                    // is a deep clone of draftStore, so no nested mutation reaches draftStore.
+                    actionArray.push({ ...cleanSnapshot[key] });
+                }
+            }
+            else {
+                // Killswitch (W-23515682): original pre-fix behavior — deep-clone every draft on
+                // every read so the internal draft store is never exposed. O(N) clones per read.
+                const { draftStore } = this;
+                const keys$1 = keys(draftStore);
+                for (let i = 0, len = keys$1.length; i < len; i++) {
+                    actionArray.push(clone(draftStore[keys$1[i]]));
+                }
             }
             return actionArray;
         });
@@ -883,8 +925,9 @@ class DurableDraftStore {
             const draft = this.draftStore[id];
             if (draft !== undefined) {
                 delete this.draftStore[id];
+                delete this.cleanSnapshot[id];
                 const durableKey = buildDraftDurableStoreKey(draft.tag, draft.id);
-                return this.durableStore.evictEntries([durableKey], DRAFT_SEGMENT);
+                return this.timeDurableOp('evictEntries', DRAFT_SEGMENT, () => this.durableStore.evictEntries([durableKey], DRAFT_SEGMENT));
             }
             return Promise.resolve();
         };
@@ -900,10 +943,11 @@ class DurableDraftStore {
                 const action = draftStore[key];
                 if (action.tag === tag) {
                     delete draftStore[action.id];
+                    delete this.cleanSnapshot[action.id];
                     durableKeys.push(buildDraftDurableStoreKey(action.tag, action.id));
                 }
             }
-            return this.durableStore.evictEntries(durableKeys, DRAFT_SEGMENT);
+            return this.timeDurableOp('evictEntries', DRAFT_SEGMENT, () => this.durableStore.evictEntries(durableKeys, DRAFT_SEGMENT));
         };
         return this.enqueueAction(deleteAction);
     }
@@ -917,6 +961,7 @@ class DurableDraftStore {
                     const action = draftStore[operation.id];
                     if (action !== undefined) {
                         delete draftStore[operation.id];
+                        delete this.cleanSnapshot[operation.id];
                         const key = buildDraftDurableStoreKey(action.tag, action.id);
                         durableStoreOperations.push({
                             ids: [key],
@@ -929,6 +974,7 @@ class DurableDraftStore {
                     const { action } = operation;
                     const key = buildDraftDurableStoreKey(action.tag, action.id);
                     draftStore[action.id] = action;
+                    this.cleanSnapshot[action.id] = clone(action);
                     durableStoreOperations.push({
                         type: 'setEntries',
                         segment: DRAFT_SEGMENT,
@@ -940,7 +986,7 @@ class DurableDraftStore {
                     });
                 }
             }
-            return this.durableStore.batchOperations(durableStoreOperations);
+            return this.timeDurableOp('batchOperations', DRAFT_SEGMENT, () => this.durableStore.batchOperations(durableStoreOperations));
         };
         return this.enqueueAction(action);
     }
@@ -983,6 +1029,7 @@ class DurableDraftStore {
                 .then((durableEntries) => {
                 if (durableEntries === undefined) {
                     this.draftStore = {};
+                    this.cleanSnapshot = {};
                     return this.runQueuedOperations();
                 }
                 const { draftStore } = this;
@@ -999,6 +1046,7 @@ class DurableDraftStore {
                         }
                     }
                     draftStore[action.id] = action;
+                    this.cleanSnapshot[action.id] = clone(action);
                 }
                 return this.runQueuedOperations();
             })

package/dist/types/DraftQueueInstrumentation.d.ts

@@ -0,0 +1,5 @@
+export interface DraftQueueInstrumentation {
+    onGetQueueActions?(durationMs: number, actionCount: number): void;
+    onNotifyChangedListeners?(eventType: string, listenerCount: number): void;
+    onDurableOperation?(op: string, segment: string, durationMs: number): void;
+}

package/dist/types/DurableDraftQueue.d.ts

@@ -3,6 +3,7 @@ import { ProcessActionResult, DraftQueueState } from './DraftQueue';
 import type { CustomActionExecutor } from './actionHandlers/CustomActionHandler';
 import type { ActionHandler } from './actionHandlers/ActionHandler';
 import type { DraftStore } from './DraftStore';
+import type { DraftQueueInstrumentation } from './DraftQueueInstrumentation';
 import type { ObservabilityContext } from '@salesforce/nimbus-plugin-lds';
 export declare const DRAFT_SEGMENT = "DRAFT";
 /**
@@ -27,8 +28,9 @@ export declare class DurableDraftQueue implements DraftQueue {
     private logger;
     private workerPool;
     private handlers;
+    private instrumentation?;
     private getHandler;
-    constructor(draftStore: DraftStore);
+    constructor(draftStore: DraftStore, instrumentation?: DraftQueueInstrumentation);
     addHandler<Data>(handler: ActionHandler<Data, unknown>): Promise<void>;
     removeHandler(id: string): Promise<void>;
     addCustomHandler(id: string, executor: CustomActionExecutor): Promise<void>;

package/dist/types/DurableDraftStore.d.ts

@@ -1,6 +1,7 @@
 import type { DurableStore } from '@luvio/environments';
 import type { DraftAction, QueueOperation } from './DraftQueue';
 import type { DraftStore } from './DraftStore';
+import type { DraftQueueInstrumentation } from './DraftQueueInstrumentation';
 /**
  * Implements a write-through InMemoryStore for Drafts, storing all drafts in a
  * in-memory store with a write through to the DurableStore.
@@ -13,9 +14,13 @@ import type { DraftStore } from './DraftStore';
 export declare class DurableDraftStore implements DraftStore {
     private durableStore;
     private draftStore;
+    private cleanSnapshot;
     private syncPromise;
     private writeQueue;
-    constructor(durableStore: DurableStore);
+    private instrumentation?;
+    private useSnapshot;
+    constructor(durableStore: DurableStore, instrumentation?: DraftQueueInstrumentation, useSnapshot?: boolean);
+    private timeDurableOp;
     writeAction(action: DraftAction<unknown, unknown>): Promise<void>;
     getAllDrafts<_R, _D>(): Promise<DraftAction<unknown, unknown>[]>;
     deleteDraft(id: string): Promise<void>;

package/dist/types/main.d.ts

@@ -2,6 +2,7 @@ export { DraftQueue, DraftQueueState, DraftAction, ErrorDraftAction, PendingDraf
 export { DurableDraftQueue, DRAFT_SEGMENT, DRAFT_ACTION_RETRY_COUNT_METADATA_KEY, } from './DurableDraftQueue';
 export { generateUniqueDraftActionId, uuidv4 } from './utils/id';
 export { DurableDraftStore } from './DurableDraftStore';
+export type { DraftQueueInstrumentation } from './DraftQueueInstrumentation';
 export { DraftStore } from './DraftStore';
 export { DraftManager, DraftManagerState, DraftActionOperationType, DraftQueueItem, DraftQueueItemMetadata, } from './DraftManager';
 export { ActionHandler, ReplacingActions } from './actionHandlers/ActionHandler';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-drafts",
-    "version": "1.451.0",
+    "version": "1.453.0",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "LDS Drafts",
     "main": "dist/ldsDrafts.js",
@@ -26,10 +26,10 @@
     "dependencies": {
         "@luvio/engine": "0.161.0",
         "@luvio/environments": "0.161.0",
-        "@salesforce/lds-utils-adapters": "^1.451.0"
+        "@salesforce/lds-utils-adapters": "^1.453.0"
     },
     "devDependencies": {
-        "@salesforce/nimbus-plugin-lds": "^1.451.0"
+        "@salesforce/nimbus-plugin-lds": "^1.453.0"
     },
     "volta": {
         "extends": "../../package.json"