@salesforce/lds-runtime-aura 1.347.1 → 1.348.1

package/dist/ldsEngineCreator.js

@@ -20,6 +20,7 @@ import useRelatedListsPredictions from '@salesforce/gate/lds.pdl.useRelatedLists
 import useRelatedListPlus from '@salesforce/gate/lds.pdl.useRelatedListPlus';
 import useCmpDefPredictions from '@salesforce/gate/lds.pdl.useCmpDefPredictions';
 import applyPredictionRequestLimit from '@salesforce/gate/lds.pdl.applyRequestLimit';
+import useLocalStorage from '@salesforce/gate/lds.pdl.useLocalStorage';
 import { GetApexWireAdapterFactory, registerPrefetcher as registerPrefetcher$1 } from 'force/ldsAdaptersApex';
 import { getRecordAvatarsAdapterFactory, getRecordAdapterFactory, coerceFieldIdArray, getRecordsAdapterFactory, getRecordActionsAdapterFactory, getObjectInfosAdapterFactory, coerceObjectIdArray, getObjectInfoAdapterFactory, coerceObjectId, getRelatedListsActionsAdapterFactory, getRelatedListInfoBatchAdapterFactory, getRelatedListInfoAdapterFactory, getRelatedListRecordsBatchAdapterFactory, getRelatedListRecordsAdapterFactory, getListInfoByNameAdapterFactory, getListInfosByObjectNameAdapterFactory, getListRecordsByNameAdapterFactory, getListObjectInfoAdapterFactory, getRelatedListsInfoAdapterFactory, getRelatedListActionsAdapterFactory, getRecordId18Array, instrument, configuration, InMemoryRecordRepresentationQueryEvaluator, UiApiNamespace, RecordRepresentationRepresentationType, registerPrefetcher } from 'force/ldsAdaptersUiapi';
 import { getInstrumentation } from 'o11y/client';
@@ -428,12 +429,18 @@ class CacheControlCommand extends BaseCommand {
     constructor(services) {
         super();
         this.services = services;
-        this.keyUnsubscribe = () => { };
+        this.rebuildUnsubscribe = () => { };
+        this.refreshUnsubscribe = () => { };
         this.subscriptions = [];
-    }
-    execute() {
-        this.keyUnsubscribe();
-        const resultPromise = this.services.cacheController.execute(this.cacheControlStrategyConfig, (cache) => this.buildRequestRunner(cache));
+        this.instantiationTime = Date.now() / 1000; // in seconds
+    }
+    execute(overrides) {
+        this.rebuildUnsubscribe();
+        this.refreshUnsubscribe();
+        const mergedCacheControlConfig = mergeCacheControlConfigs(this.cacheControlStrategyConfig, overrides);
+        const resultPromise = this.services.cacheController.execute(mergedCacheControlConfig, (cache) => this.buildRequestRunner(cache), {
+            instrumentationAttributes: this.instrumentationAttributes,
+        });
         return resultPromise;
     }
     // TODO: This should likely be abstract in v2.  For v1, provide default comparison logic.
@@ -452,6 +459,7 @@ class CacheControlCommand extends BaseCommand {
     writeToCacheAndPublish(cache, networkResult) {
         const recordableCache = cache.record();
         const writeResult = this.writeToCache(recordableCache, networkResult);
+        this.instantiationTime = Date.now() / 1000;
         if (this.services.pubSub) {
             this.services.pubSub.publish({
                 type: 'cacheUpdate',
@@ -498,17 +506,12 @@ class CacheControlCommand extends BaseCommand {
         };
     }
     subscribeToKeys(keysRead, lastResult) {
-        if (this.services.pubSub === undefined) {
+        const { pubSub } = this.services;
+        if (!pubSub) {
             return;
         }
-        this.keyUnsubscribe = this.services.pubSub.subscribe({
-            type: 'cacheUpdate',
-            predicate: (event) => event.data.overlaps(keysRead),
-            callback: () => keyChangedCallback(),
-        });
-        const keyChangedCallback = () => {
-            const newResultPromise = this.execute();
-            return newResultPromise.then((result) => {
+        const executeAndHandleResult = (overrides) => {
+            return this.execute(overrides).then((result) => {
                 if (result.isErr()) {
                     this.invokeConsumerCallbacks(result);
                     return;
@@ -518,6 +521,13 @@ class CacheControlCommand extends BaseCommand {
                 }
             });
         };
+        const createKeySubscriber = (type, callback) => pubSub.subscribe({
+            type,
+            predicate: (event) => setOverlaps(event.data, keysRead),
+            callback,
+        });
+        this.rebuildUnsubscribe = createKeySubscriber('cacheUpdate', () => executeAndHandleResult({ now: this.instantiationTime }));
+        this.refreshUnsubscribe = createKeySubscriber('cacheInvalidation', () => executeAndHandleResult());
     }
     invokeConsumerCallbacks(data) {
         this.subscriptions.forEach((cb) => {
@@ -530,6 +540,45 @@ class CacheControlCommand extends BaseCommand {
         });
     }
 }
+/**
+ * Merges two CacheControlStrategyConfig objects
+ *
+ */
+function mergeCacheControlConfigs(baseConfig, overrides) {
+    var _a;
+    if (!overrides) {
+        return baseConfig;
+    }
+    const now = (_a = overrides.now) !== null && _a !== void 0 ? _a : baseConfig.now;
+    if (!overrides.cacheControlConfig) {
+        return {
+            ...baseConfig,
+            now,
+        };
+    }
+    return {
+        ...overrides.cacheControlConfig,
+        now,
+    };
+}
+// Needs TS 2023+ (esnext) AND node 20+ to remove
+function setOverlaps(setA, setB) {
+    if (setA.size > setB.size) {
+        for (const key of setB.keys()) {
+            if (setA.has(key)) {
+                return true;
+            }
+        }
+    }
+    else {
+        for (const key of setA) {
+            if (setB.has(key)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -545,7 +594,7 @@ class CacheControlCommand extends BaseCommand {
  * @typeParam NetworkResult cache result including network metadata
  * @typeParam ExtraServices additional named services needed by a subclass
  */
-class AuraResourceCacheControlCommand extends CacheControlCommand {
+class AuraCacheControlCommand extends CacheControlCommand {
     constructor(services) {
         super(services);
         this.services = services;
@@ -556,15 +605,8 @@ class AuraResourceCacheControlCommand extends CacheControlCommand {
             storable: false,
         };
     }
-    execute() {
-        return super.execute();
-    }
-    readFromCache(cache) {
-        var _a;
-        return resolvedPromiseLike(ok((_a = cache.get(this.buildKey())) === null || _a === void 0 ? void 0 : _a.value));
-    }
     requestFromNetwork() {
-        return this.convertAuraResponseToData(this.services.auraNetwork(this.endpoint, this.auraParams, this.actionConfig), this.coerceError);
+        return this.convertAuraResponseToData(this.services.auraNetwork(this.endpoint, this.auraParams, this.actionConfig), (errs) => this.coerceError(errs));
     }
     coerceError(auraErrors) {
         return toError(auraErrors[0]); // Default Implementation stringifies the response
@@ -585,6 +627,34 @@ class AuraResourceCacheControlCommand extends CacheControlCommand {
             return err(toError('Error fetching component'));
         });
     }
+}
+
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+
+/**
+ * An implementation of BaseCommand that allows for extending abstract cache methods
+ *
+ * @typeParam Data cache result for read operations
+ * @typeParam NetworkResult cache result including network metadata
+ * @typeParam ExtraServices additional named services needed by a subclass
+ */
+class AuraResourceCacheControlCommand extends AuraCacheControlCommand {
+    constructor(services) {
+        super(services);
+        this.services = services;
+    }
+    execute() {
+        return super.execute();
+    }
+    readFromCache(cache) {
+        var _a;
+        return resolvedPromiseLike(ok((_a = cache.get(this.buildKey())) === null || _a === void 0 ? void 0 : _a.value));
+    }
     writeToCache(cache, networkResult) {
         if (networkResult.isOk()) {
             cache.set(this.buildKey(), {
@@ -623,18 +693,18 @@ class FetchNetworkCommand extends NetworkCommand {
         this.services = services;
     }
     fetch() {
-        return this.convertFetchResponseToData(this.services.fetch(...this.fetchParams), this.coerceError);
+        return this.convertFetchResponseToData(this.services.fetch(...this.fetchParams));
     }
     async coerceError(errorResponse) {
         return toError(errorResponse.statusText); // Default Behavior
     }
-    convertFetchResponseToData(response, coerceError) {
+    convertFetchResponseToData(response) {
         return response.then((response) => {
             if (response.ok) {
                 return response.json().then((json) => ok(json), (reason) => err(toError(reason)));
             }
             else {
-                return coerceError(response).then((coercedError) => err(coercedError));
+                return this.coerceError(response).then((coercedError) => err(coercedError));
             }
         }, (reason) => err(toError(reason)));
     }
@@ -818,9 +888,9 @@ function buildInstrumentCommand(services) {
             execute(...args) {
                 invocationCounter.add(1);
                 let result;
-                const start = performance.now();
+                const start = services.instrumentation.currentTimeMs();
                 function recordDuration() {
-                    const end = performance.now();
+                    const end = services.instrumentation.currentTimeMs();
                     durationHistogram.record(end - start);
                 }
                 try {
@@ -1027,12 +1097,12 @@ class O11yCounter {
         this.o11yInstrumentation = o11yInstrumentation;
         this.logger = logger;
     }
-    add(value, _attributes, _context) {
+    add(value, attributes, _context) {
         if (value < 0) {
             this.logger.warn(`Counter values must be non-negative. Got ${value}.`);
             return;
         }
-        this.o11yInstrumentation.incrementCounter(this.name, value);
+        this.o11yInstrumentation.incrementCounter(this.name, value, undefined, sanitizeAttributes(attributes));
     }
 }
 class O11yHistogram {
@@ -1041,12 +1111,12 @@ class O11yHistogram {
         this.o11yInstrumentation = o11yInstrumentation;
         this.logger = logger;
     }
-    record(value, _attributes, _context) {
+    record(value, attributes, _context) {
         if (value < 0) {
             this.logger.warn(`Histogram values must be non-negative. Got ${value}.`);
             return;
         }
-        this.o11yInstrumentation.trackValue(this.name, value);
+        this.o11yInstrumentation.trackValue(this.name, value, undefined, sanitizeAttributes(attributes));
     }
 }
 class O11yUpDownCounter {
@@ -1090,10 +1160,22 @@ class O11yObservableUpDownCounter {
         this.logger.warn('O11yObservableUpDownCounter not supported yet. Defaulting to noop.');
     }
 }
+function sanitizeAttributes(attributes) {
+    if (!attributes)
+        return;
+    const metricTags = {};
+    Object.entries(attributes).forEach(([key, value]) => {
+        if (value !== undefined && !Array.isArray(value)) {
+            metricTags[key] = value;
+        }
+    });
+    return metricTags;
+}
 
 class O11yInstrumentation {
     constructor(services) {
         this.services = services;
+        this.currentTimeMs = () => performance.now();
         this.trace = new O11yOTelTraceAPI(this.services);
         this.metrics = new O11yOTelMetricsAPI(this.services);
     }
@@ -1113,63 +1195,6 @@ function buildServiceDescriptor$4(logger) {
  */
 
 
-/**
- * A collection of keys, in no particular order.
- */
-class KeySetImpl {
-    constructor(initialKeys) {
-        // TODO - probably better to use Set<Key>
-        this.data = {};
-        this.lengthInternal = 0;
-        if (initialKeys) {
-            initialKeys.forEach((key) => {
-                this.add(key);
-            });
-        }
-    }
-    add(key) {
-        this.data[key] = true;
-        // TODO - need to account for adding a key that was already in the set
-        this.lengthInternal++;
-    }
-    contains(key) {
-        return this.data[key] === true;
-    }
-    elements() {
-        return Object.keys(this.data);
-    }
-    get length() {
-        return this.lengthInternal;
-    }
-    overlaps(other) {
-        const otherKeys = other.elements();
-        for (let j = 0; j < otherKeys.length; ++j) {
-            if (this.contains(otherKeys[j])) {
-                return true;
-            }
-        }
-        return false;
-    }
-    difference(other) {
-        const value = new KeySetImpl();
-        this.elements().forEach((key) => {
-            if (!other.contains(key)) {
-                value.add(key);
-            }
-        });
-        return value;
-    }
-    isSubsetOf(other) {
-        return this.difference(other).length === 0;
-    }
-    equals(other) {
-        return this.length === other.length && this.elements().every((key) => other.contains(key));
-    }
-    toString() {
-        return `<<${JSON.stringify(this.elements())}>>`;
-    }
-}
-
 /* eslint-disable no-dupe-class-members */
 /**
  A utility class for recording actions made on a cache.
@@ -1177,10 +1202,10 @@ class KeySetImpl {
 class DefaultRecordableCache {
     constructor(baseCache) {
         this.baseCache = baseCache;
-        this.keysRead = new KeySetImpl();
-        this.missingKeysRead = new KeySetImpl();
-        this.keysUpdated = new KeySetImpl();
-        this.metadataKeysUpdated = new KeySetImpl();
+        this.keysRead = new Set();
+        this.missingKeysRead = new Set();
+        this.keysUpdated = new Set();
+        this.metadataKeysUpdated = new Set();
     }
     delete(key) {
         this.keysUpdated.add(key);
@@ -1212,8 +1237,8 @@ class DefaultRecordableCache {
     keys() {
         return this.baseCache.keys();
     }
-    toKeySet(keys) {
-        return this.baseCache.toKeySet(keys);
+    entries() {
+        return this.baseCache.entries();
     }
     record() {
         return new DefaultRecordableCache(this);
@@ -1221,6 +1246,9 @@ class DefaultRecordableCache {
     filter(predicate) {
         return new DefaultFilteredCache(this, predicate);
     }
+    buildFixedTimeWritableCache(generatedTime) {
+        return new FixedTimeWritableCache(this, generatedTime);
+    }
 }
 /**
  A utility class for filtering cache entries based on a given predicate.
@@ -1251,13 +1279,13 @@ class DefaultFilteredCache {
         this.baseCache.setMetadata(key, cacheControlMetadata);
     }
     length() {
-        return this.getFilteredKeys().length;
+        return this.getFilteredKeys().size;
     }
     keys() {
         return this.getFilteredKeys();
     }
-    toKeySet(keys) {
-        return this.baseCache.toKeySet(keys);
+    entries() {
+        return this.getFilteredEntries();
     }
     record() {
         return new DefaultRecordableCache(this);
@@ -1265,18 +1293,71 @@ class DefaultFilteredCache {
     filter(predicate) {
         return new DefaultFilteredCache(this, predicate);
     }
+    getFilteredEntries() {
+        return this.baseCache.entries().filter(([key, _value]) => {
+            return this.get(key);
+        });
+    }
     getFilteredKeys() {
-        const filteredKeySet = new KeySetImpl();
-        this.baseCache
-            .keys()
-            .elements()
-            .forEach((key) => {
+        const filteredKeySet = new Set();
+        this.baseCache.keys().forEach((key) => {
             if (this.get(key)) {
                 filteredKeySet.add(key);
             }
         });
         return filteredKeySet;
     }
+    buildFixedTimeWritableCache(generatedTime) {
+        return new FixedTimeWritableCache(this, generatedTime);
+    }
+}
+/**
+ A utility class for automatically setting the generated time on all write operations
+ */
+class FixedTimeWritableCache {
+    constructor(baseCache, generatedTime) {
+        this.baseCache = baseCache;
+        this.generatedTime = generatedTime;
+    }
+    delete(key) {
+        this.baseCache.delete(key);
+    }
+    get(key, options) {
+        return this.baseCache.get(key, options);
+    }
+    set(key, value) {
+        this.baseCache.set(key, {
+            ...value,
+            metadata: {
+                ...value.metadata,
+                cacheControl: { ...value.metadata.cacheControl, generatedTime: this.generatedTime },
+            },
+        });
+    }
+    setMetadata(key, cacheControlMetadata) {
+        this.baseCache.setMetadata(key, {
+            ...cacheControlMetadata,
+            generatedTime: this.generatedTime,
+        });
+    }
+    length() {
+        return this.baseCache.length();
+    }
+    keys() {
+        return this.baseCache.keys();
+    }
+    entries() {
+        return this.baseCache.entries();
+    }
+    record() {
+        return new DefaultRecordableCache(this);
+    }
+    filter(predicate) {
+        return new DefaultFilteredCache(this, predicate);
+    }
+    buildFixedTimeWritableCache(generatedTime) {
+        return new FixedTimeWritableCache(this, generatedTime);
+    }
 }
 
 /* eslint-disable no-dupe-class-members */
@@ -1300,7 +1381,20 @@ class DefaultCache {
         if (entry.metadata.cacheControl.type === 'no-store') {
             return;
         }
-        this.data[key] = entry;
+        this.data[key] = {
+            ...entry,
+            metadata: {
+                ...entry.metadata,
+                type: entry.metadata.type || {
+                    namespace: 'OneStore:Internal',
+                    name: 'UnknownType',
+                },
+                cacheControl: {
+                    generatedTime: Date.now() / 1000,
+                    ...entry.metadata.cacheControl,
+                },
+            },
+        };
     }
     /**
      * Removes the cache entry associated with the specified key.
@@ -1319,17 +1413,20 @@ class DefaultCache {
      */
     setMetadata(key, cacheControlMetadata) {
         if (key in this.data) {
-            this.data[key].metadata.cacheControl = cacheControlMetadata;
+            this.data[key].metadata.cacheControl = {
+                generatedTime: Date.now() / 1000,
+                ...cacheControlMetadata,
+            };
         }
     }
     length() {
-        return this.keys().length;
+        return this.keys().size;
     }
     keys() {
-        return new KeySetImpl(Object.keys(this.data));
+        return new Set(Object.keys(this.data));
     }
-    toKeySet(keys) {
-        return new KeySetImpl(keys);
+    entries() {
+        return Object.entries(this.data);
     }
     record() {
         return new DefaultRecordableCache(this);
@@ -1337,6 +1434,9 @@ class DefaultCache {
     filter(predicate) {
         return new DefaultFilteredCache(this, predicate);
     }
+    buildFixedTimeWritableCache(generatedTime) {
+        return new FixedTimeWritableCache(this, generatedTime);
+    }
 }
 
 function buildServiceDescriptor$3() {
@@ -1379,15 +1479,19 @@ class CacheControlStrategy {
 }
 
 class MaxAgeCacheControlStrategy extends CacheControlStrategy {
-    execute() {
+    execute(options) {
+        const startTime = this.services.instrumentation
+            ? this.services.instrumentation.currentTimeMs()
+            : 0;
         return this.requestRunner.readFromCache().then((value) => {
             if (this.isCacheHit(value)) {
+                this.collectCacheHitInstrumentation(startTime, options === null || options === void 0 ? void 0 : options.instrumentationAttributes);
                 return value;
             }
-            return this.handleCacheMiss();
+            return this.handleCacheMiss(startTime, options === null || options === void 0 ? void 0 : options.instrumentationAttributes);
         });
     }
-    handleCacheMiss() {
+    handleCacheMiss(startTime, instrumentationAttributes) {
         let error;
         return this.requestRunner
             .requestFromNetwork()
@@ -1411,17 +1515,155 @@ class MaxAgeCacheControlStrategy extends CacheControlStrategy {
             if (!this.isCacheHit(value)) {
                 return err(new Error('Cache miss after fetching from network'));
             }
+            this.collectCacheMissInstrumentation(startTime, instrumentationAttributes);
             return value;
         });
     }
+    collectCacheHitInstrumentation(startTime, instrumentationAttributes) {
+        if (this.services.instrumentation) {
+            const meter = this.services.instrumentation.metrics.getMeter('onestore');
+            meter
+                .createCounter(`command.max-age.cache-hit.count`)
+                .add(1, instrumentationAttributes);
+            meter
+                .createHistogram(`command.max-age.cache-hit.duration`)
+                .record(this.services.instrumentation.currentTimeMs() - startTime, instrumentationAttributes);
+        }
+    }
+    collectCacheMissInstrumentation(startTime, instrumentationAttributes) {
+        if (this.services.instrumentation) {
+            const meter = this.services.instrumentation.metrics.getMeter('onestore');
+            meter
+                .createCounter(`command.max-age.cache-miss.count`)
+                .add(1, instrumentationAttributes);
+            meter
+                .createHistogram(`command.max-age.cache-miss.duration`)
+                .record(this.services.instrumentation.currentTimeMs() - startTime, instrumentationAttributes);
+        }
+    }
     get expiredChecks() {
+        const config = this.config;
         return [
             ...super.expiredChecks,
-            (cacheControlMetadata) => cacheControlMetadata.generatedTime + this.config.requestMaxAge < this.config.now,
+            (cacheControlMetadata) => {
+                return cacheControlMetadata.generatedTime + config.requestMaxAge < config.now;
+            },
         ];
     }
 }
 
+class NoCacheCacheControlStrategy extends CacheControlStrategy {
+    execute() {
+        return this.requestRunner.requestFromNetwork().then((networkResult) => {
+            if (networkResult.isErr()) {
+                return networkResult;
+            }
+            // Attempt to write to the cache
+            return this.requestRunner
+                .writeToCache(networkResult)
+                .then(() => this.requestRunner.readFromCache())
+                .then((cachedResult) => {
+                if (!this.isCacheHit(cachedResult)) {
+                    return err(new Error('Cache miss after saving network result'));
+                }
+                return cachedResult;
+            });
+        });
+    }
+}
+
+const isAndQuery = (query) => '$and' in query;
+const isOrQuery = (query) => '$or' in query;
+const isNotQuery = (query) => '$not' in query;
+const matchesMetadata = (metadataQuery, cacheControl) => {
+    var _a;
+    if ('cacheControlType' in metadataQuery &&
+        cacheControl.type !== metadataQuery.cacheControlType.$eq) {
+        return false;
+    }
+    if ('maxAge' in metadataQuery && cacheControl.type === 'max-age') {
+        const maxAge = (_a = cacheControl.maxAge) !== null && _a !== void 0 ? _a : 0;
+        if ((metadataQuery.maxAge.$gte !== undefined && maxAge < metadataQuery.maxAge.$gte) ||
+            (metadataQuery.maxAge.$lte !== undefined && maxAge > metadataQuery.maxAge.$lte)) {
+            return false;
+        }
+    }
+    return true;
+};
+function queryToPredicate(query) {
+    return (key, entry) => {
+        if (!query)
+            return false;
+        if (isAndQuery(query))
+            return query.$and.every((subQuery) => queryToPredicate(subQuery)(key, entry));
+        if (isOrQuery(query))
+            return query.$or.some((subQuery) => queryToPredicate(subQuery)(key, entry));
+        if (isNotQuery(query))
+            return !queryToPredicate(query.$not)(key, entry);
+        if ('key' in query)
+            return matchesKey(query.key, key);
+        if ('metadata' in query)
+            return matchesMetadata(query.metadata, entry.metadata.cacheControl);
+        if ('value' in query)
+            return false; // TODO: Not implemented
+        throw new Error('Unknown Query Operation');
+    };
+}
+function matchesKey(keyQuery, key) {
+    if ('$regex' in keyQuery) {
+        return keyQuery.$regex.test(key);
+    }
+    return false;
+}
+
+/**
+ * Processes a cache update operation and determines the appropriate modification.
+ *
+ * This function analyzes the provided `update` and the `existing` cache entry
+ * to determine the necessary update type. It returns one of three possible outcomes:
+ *
+ * - `{ type: 'entry', entry }`: A full cache entry update, including both value and metadata.
+ * - `{ type: 'metadata', metadata }`: A metadata-only update, leaving the value unchanged.
+ * - `{ type: 'no-op' }`: No changes are needed, and the cache should remain as is.
+ *
+ * @param update - The cache update operation to apply.
+ * @param existing - The existing cache entry being modified.
+ * @returns An object indicating the type of update:
+ *   - A full cache entry update (`type: 'entry'`)
+ *   - A metadata-only update (`type: 'metadata'`)
+ *   - A no-op (`type: 'no-op'`) if no changes are required.
+ */
+function buildUpdate(update, existing) {
+    switch (update.type) {
+        case 'invalidate':
+            const updatedCacheControl = buildInvalidatedCacheControl(existing.metadata.cacheControl);
+            return updatedCacheControl !== undefined
+                ? { type: 'metadata', metadata: updatedCacheControl }
+                : { type: 'no-op' };
+        default:
+            throw new Error(`Invalid update operation: ${update.type}`);
+    }
+}
+/**
+ * Builds an updated CacheControlMetadata object that invalidates the cache entry.
+ *
+ * @param existingCacheControl - The current CacheControlMetadata.
+ * @returns A new CacheControlMetadata object with `maxAge` set to `0`, or undefined if no changes are needed.
+ */
+function buildInvalidatedCacheControl(existingCacheControl) {
+    switch (existingCacheControl.type) {
+        case 'max-age':
+        case 'stale-while-revalidate':
+            if (existingCacheControl.maxAge !== 0) {
+                return {
+                    ...existingCacheControl,
+                    maxAge: 0,
+                };
+            }
+    }
+    return undefined; // No-op: no changes
+}
+
 /**
  * A class that allows the execution of requested cache control strategies,
  * while also enforcing the canonical cache control metadata.
@@ -1430,16 +1672,50 @@ class CacheController {
     constructor(services) {
         this.services = services;
     }
-    execute(config, buildRequestRunner) {
+    execute(config, buildRequestRunner, options) {
         const strategy = this.getCacheControlStrategy(config, buildRequestRunner);
-        return strategy.execute();
+        return strategy.execute(options);
     }
     getCacheControlStrategy(config, buildRequestRunner) {
         if (config.type === 'max-age') {
             return new MaxAgeCacheControlStrategy(this.services, config, buildRequestRunner);
         }
+        else if (config.type === 'no-cache') {
+            return new NoCacheCacheControlStrategy(this.services, config, buildRequestRunner);
+        }
         throw new Error(`Unknown cache control strategy ${config.type}`);
     }
+    /**
+     * Finds cache entries that match the given query.
+     * Returns an async generator that yields `[key, entry]`.
+     */
+    async *find(query) {
+        const cache = this.services.cache;
+        const predicate = queryToPredicate(query);
+        const filteredEntries = cache.filter(predicate).entries();
+        for (const entry of filteredEntries) {
+            yield entry;
+        }
+    }
+    /**
+     * Finds and modifies cache entries that match the given query.
+     * Extends `find(query)` and returns an async generator of modified keys.
+     */
+    async *findAndModify(query, cacheUpdate) {
+        for await (const [key, value] of this.find(query)) {
+            const update = buildUpdate(cacheUpdate, value);
+            switch (update.type) {
+                case 'entry':
+                    this.services.cache.set(key, update.entry);
+                    yield key;
+                    break;
+                case 'metadata':
+                    this.services.cache.setMetadata(key, update.metadata);
+                    yield key;
+                    break;
+            }
+        }
+    }
 }
 
 function buildServiceDescriptor$2(cache) {
@@ -4926,6 +5202,22 @@ function buildAuraPrefetchStorage(options = {}) {
     }
     return new AuraPrefetchStorage(auraStorage, inMemoryStorage, onPredictionsReadyCallback);
 }
+function buildAuraLocalStoragePrefetchStorage(options = {}) {
+    const { onPredictionsReadyCallback, ...storageOptions } = options;
+    const auraStorage = createStorage({
+        ...DEFAULT_STORAGE_OPTIONS,
+        ...storageOptions,
+        secure: false,
+        adapter: 'localstorage',
+        name: 'pdl',
+        maxSize: 4096000, // 4MB
+    });
+    if (auraStorage === null) {
+        return buildAuraPrefetchStorage(options);
+    }
+    const inMemoryStorage = new InMemoryPrefetchStorage();
+    return new AuraPrefetchStorage(auraStorage, inMemoryStorage, onPredictionsReadyCallback);
+}
 class AuraPrefetchStorage {
     constructor(auraStorage, inMemoryStorage, onPredictionsReadyCallback = () => { }) {
         this.auraStorage = auraStorage;
@@ -4963,6 +5255,26 @@ class AuraPrefetchStorage {
     }
 }
 
+function isLocalStorageAvailable() {
+    try {
+        const testKey = 'test';
+        window.localStorage.setItem(testKey, '1');
+        window.localStorage.removeItem(testKey);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+function buildPrefetchStorage(useLocalStorage, options) {
+    if (useLocalStorage && isLocalStorageAvailable()) {
+        return buildAuraLocalStoragePrefetchStorage(options);
+    }
+    else {
+        return buildAuraPrefetchStorage(options);
+    }
+}
+
 class NoComposedAdapterTypeError extends TypeError {
     constructor(message, resourceRequest) {
         super(message);
@@ -5018,7 +5330,7 @@ function getEnvironmentSetting(name) {
     }
     return undefined;
 }
-// version: 1.347.1-60ff64f212
+// version: 1.348.1-163f0bd450
 
 const forceRecordTransactionsDisabled = getEnvironmentSetting(EnvironmentSettings.ForceRecordTransactionsDisabled);
 //TODO: Some duplication here that can be most likely moved to a util class
@@ -5511,7 +5823,7 @@ function setupPredictivePrefetcher(luvio) {
         new GetRelatedListActionsRequestStrategy(luvio),
     ];
     requestStrategyManager.register(allStrategies);
-    const storage = buildAuraPrefetchStorage({
+    const storage = buildPrefetchStorage(useLocalStorage.isOpen({ fallback: false }), {
         onPredictionsReadyCallback: () => predictionsReadyManager.notifyPredictionsReady(),
     });
     const requestRunner = new LexRequestRunner(requestStrategyManager);
@@ -5708,4 +6020,4 @@ function ldsEngineCreator() {
 }
 
 export { LexRequestStrategy, PdlRequestPriority, buildPredictorForContext, ldsEngineCreator as default, initializeLDS, initializeOneStore, registerRequestStrategy, saveRequestAsPrediction, unregisterRequestStrategy, whenPredictionsReady };
-// version: 1.347.1-71b4105fee
+// version: 1.348.1-44d4bea72f

package/dist/types/predictive-loading/storage/aura-prefetch-storage.d.ts

@@ -11,9 +11,11 @@ export declare const DEFAULT_STORAGE_OPTIONS: {
     debugLogging: boolean;
     version: number;
 };
-export declare function buildAuraPrefetchStorage(options?: Partial<AuraStorageConfig> & {
+export type StorageOptions = Partial<AuraStorageConfig> & {
     onPredictionsReadyCallback?: () => void;
-}): PrefetchStorage;
+};
+export declare function buildAuraPrefetchStorage(options?: StorageOptions): PrefetchStorage;
+export declare function buildAuraLocalStoragePrefetchStorage(options?: StorageOptions): PrefetchStorage;
 export declare class AuraPrefetchStorage implements PrefetchStorage {
     private auraStorage;
     private inMemoryStorage;

package/dist/types/predictive-loading/storage/index.d.ts

@@ -1,7 +1,8 @@
+import { StorageOptions } from './aura-prefetch-storage';
 export type PrefetchStorage = {
     get<T>(key: string): T | undefined;
     set<T>(key: string, value: T): Promise<void>;
 };
+export declare function buildPrefetchStorage(useLocalStorage: boolean, options: StorageOptions): PrefetchStorage;
 export * from './in-memory-prefetch-storage';
 export * from './local-prefetch-storage';
-export { buildAuraPrefetchStorage } from './aura-prefetch-storage';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-runtime-aura",
-    "version": "1.347.1",
+    "version": "1.348.1",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "LDS engine for Aura runtime",
     "main": "dist/ldsEngineCreator.js",
@@ -34,44 +34,44 @@
         "release:corejar": "yarn build && ../core-build/scripts/core.js --name=lds-runtime-aura"
     },
     "devDependencies": {
-        "@luvio/service-provisioner": "5.29.0",
-        "@salesforce/lds-adapters-apex": "^1.347.1",
-        "@salesforce/lds-adapters-uiapi": "^1.347.1",
+        "@luvio/service-provisioner": "5.33.0",
+        "@salesforce/lds-adapters-apex": "^1.348.1",
+        "@salesforce/lds-adapters-uiapi": "^1.348.1",
         "@salesforce/lds-adapters-uiapi-lex": "^1.302.0",
-        "@salesforce/lds-ads-bridge": "^1.347.1",
-        "@salesforce/lds-aura-storage": "^1.347.1",
-        "@salesforce/lds-bindings": "^1.347.1",
-        "@salesforce/lds-instrumentation": "^1.347.1",
-        "@salesforce/lds-network-aura": "^1.347.1",
-        "@salesforce/lds-network-fetch": "^1.347.1",
+        "@salesforce/lds-ads-bridge": "^1.348.1",
+        "@salesforce/lds-aura-storage": "^1.348.1",
+        "@salesforce/lds-bindings": "^1.348.1",
+        "@salesforce/lds-instrumentation": "^1.348.1",
+        "@salesforce/lds-network-aura": "^1.348.1",
+        "@salesforce/lds-network-fetch": "^1.348.1",
         "jwt-encode": "1.0.1"
     },
     "dependencies": {
-        "@luvio/command-aura-network": "5.29.0",
-        "@luvio/command-aura-resource-cache-control": "5.29.0",
-        "@luvio/command-fetch-network": "5.29.0",
-        "@luvio/command-network": "5.29.0",
-        "@luvio/command-sse": "5.29.0",
-        "@luvio/command-streaming": "5.29.0",
+        "@luvio/command-aura-network": "5.33.0",
+        "@luvio/command-aura-resource-cache-control": "5.33.0",
+        "@luvio/command-fetch-network": "5.33.0",
+        "@luvio/command-network": "5.33.0",
+        "@luvio/command-sse": "5.33.0",
+        "@luvio/command-streaming": "5.33.0",
         "@luvio/network-adapter-composable": "0.156.7",
         "@luvio/network-adapter-fetch": "0.156.7",
-        "@luvio/service-aura-network": "5.29.0",
-        "@luvio/service-cache": "5.29.0",
-        "@luvio/service-cache-control": "5.29.0",
-        "@luvio/service-fetch-network": "5.29.0",
-        "@luvio/service-instrument-command": "5.29.0",
-        "@luvio/service-pubsub": "5.29.0",
-        "@luvio/service-store": "5.29.0",
-        "@luvio/utils": "5.29.0",
-        "@salesforce/lds-adapters-uiapi-lex": "^1.347.1"
+        "@luvio/service-aura-network": "5.33.0",
+        "@luvio/service-cache": "5.33.0",
+        "@luvio/service-cache-control": "5.33.0",
+        "@luvio/service-fetch-network": "5.33.0",
+        "@luvio/service-instrument-command": "5.33.0",
+        "@luvio/service-pubsub": "5.33.0",
+        "@luvio/service-store": "5.33.0",
+        "@luvio/utils": "5.33.0",
+        "@salesforce/lds-adapters-uiapi-lex": "^1.348.1"
     },
     "luvioBundlesize": [
         {
             "path": "./dist/ldsEngineCreator.js",
             "maxSize": {
-                "none": "215 kB",
-                "min": "89 kB",
-                "compressed": "38 kB"
+                "none": "226.5 kB",
+                "min": "93.5 kB",
+                "compressed": "39.5 kB"
             }
         }
     ],