@salesforce/lds-runtime-aura 1.344.0 → 1.346.0

package/dist/ldsEngineCreator.js

@@ -73,7 +73,7 @@ class NetworkCommand extends BaseCommand {
         return this.fetch();
     }
 }
-function buildServiceDescriptor$a() {
+function buildServiceDescriptor$b() {
     return {
         type: 'networkCommandBaseClass',
         version: '1.0',
@@ -219,6 +219,54 @@ function rejectedPromiseLike(reason) {
 function isPromiseLike(x) {
     return typeof x === 'object' && typeof (x === null || x === void 0 ? void 0 : x.then) === 'function';
 }
+
+/**
+ * Recursively compares two values and indicates if they are equal.
+ *
+ * @param x first value
+ * @param y second value
+ * @returns true if x and y are recursively equal to each other; false if not
+ */
+function deepEquals$1(x, y) {
+    if (x === undefined) {
+        return y === undefined;
+    }
+    else if (x === null) {
+        return y === null;
+    }
+    else if (y === null) {
+        return x === null;
+    }
+    else if (isArray$2(x)) {
+        if (!isArray$2(y) || x.length !== y.length) {
+            return false;
+        }
+        for (let i = 0; i < x.length; ++i) {
+            if (!deepEquals$1(x[i], y[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    else if (typeof x === 'object') {
+        if (typeof y !== 'object') {
+            return false;
+        }
+        const xkeys = Object.keys(x);
+        const ykeys = Object.keys(y);
+        if (xkeys.length !== ykeys.length) {
+            return false;
+        }
+        for (let i = 0; i < xkeys.length; ++i) {
+            const key = xkeys[i];
+            if (!deepEquals$1(x[key], y[key])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return x === y;
+}
 /**
  * A deterministic JSON stringify implementation. Heavily adapted from https://github.com/epoberezkin/fast-json-stable-stringify.
  * This is needed because insertion order for JSON.stringify(object) affects output:
@@ -354,7 +402,7 @@ class AuraNetworkCommand extends NetworkCommand {
     }
 }
 
-function buildServiceDescriptor$9() {
+function buildServiceDescriptor$a() {
     return {
         type: 'auraNetworkCommandBaseClass',
         version: '1.0',
@@ -380,17 +428,107 @@ class CacheControlCommand extends BaseCommand {
     constructor(services) {
         super();
         this.services = services;
+        this.keyUnsubscribe = () => { };
+        this.subscriptions = [];
     }
     execute() {
-        return this.services.cacheController.execute(this.cacheControlStrategyConfig, (cache) => this.buildRequestRunner(cache));
+        this.keyUnsubscribe();
+        const resultPromise = this.services.cacheController.execute(this.cacheControlStrategyConfig, (cache) => this.buildRequestRunner(cache));
+        return resultPromise;
+    }
+    // TODO: This should likely be abstract in v2.  For v1, provide default comparison logic.
+    equals(result1, result2) {
+        return deepEquals$1(result1, result2);
     }
     buildRequestRunner(cache) {
         return {
-            readFromCache: () => this.readFromCache(cache),
+            readFromCache: () => this.buildResultWithSubscribe(cache),
             requestFromNetwork: () => this.requestFromNetwork(),
-            writeToCache: (networkResult) => this.writeToCache(cache, networkResult),
+            writeToCache: (networkResult) => this.writeToCacheAndPublish(cache, networkResult),
         };
     }
+    // TODO: This is added as a temporary measure for ensuring that cache write events are
+    // published to pubSub. A follow-up will be required to find the right home for this logic.
+    writeToCacheAndPublish(cache, networkResult) {
+        const recordableCache = cache.record();
+        const writeResult = this.writeToCache(recordableCache, networkResult);
+        if (this.services.pubSub) {
+            this.services.pubSub.publish({
+                type: 'cacheUpdate',
+                data: recordableCache.keysUpdated,
+            });
+        }
+        return writeResult;
+    }
+    buildResultWithSubscribe(cache) {
+        const recordableCache = cache.record();
+        const result = this.readFromCache(recordableCache);
+        return result.then((readResult) => {
+            if (readResult.isErr()) {
+                return err(readResult.error);
+            }
+            else {
+                const data = readResult.value;
+                if (data !== undefined) {
+                    this.subscribeToKeys(recordableCache.keysRead, data);
+                    return ok({
+                        data,
+                        subscribe: this.buildSubscribe(),
+                    });
+                }
+                return ok(undefined);
+            }
+        });
+    }
+    /**
+     * Builds a function that subscribes to cache changes via the pubsub service. Whenever
+     * relevant cache updates occur, it re-reads the data and compares it against
+     * the last known value. If a change is detected, the provided
+     * callback is invoked.
+     *
+     * @param keysRead - keys of interest that were read during readFromCache
+     * @returns an unsubscribe function to stop watching for updates
+     */
+    buildSubscribe() {
+        return (consumerCallback) => {
+            this.subscriptions.push(consumerCallback);
+            return () => {
+                this.subscriptions = this.subscriptions.filter((cb) => cb !== consumerCallback);
+            };
+        };
+    }
+    subscribeToKeys(keysRead, lastResult) {
+        if (this.services.pubSub === undefined) {
+            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) => {
+                if (result.isErr()) {
+                    this.invokeConsumerCallbacks(result);
+                    return;
+                }
+                if (!this.equals(lastResult, result.value.data)) {
+                    this.invokeConsumerCallbacks(ok(result.value.data));
+                }
+            });
+        };
+    }
+    invokeConsumerCallbacks(data) {
+        this.subscriptions.forEach((cb) => {
+            try {
+                cb(data);
+            }
+            catch (error) {
+                // TODO: Add logging here
+            }
+        });
+    }
 }
 
 /**
@@ -461,7 +599,7 @@ class AuraResourceCacheControlCommand extends CacheControlCommand {
     }
 }
 
-function buildServiceDescriptor$8() {
+function buildServiceDescriptor$9() {
     return {
         type: 'auraResourceCacheControlCommand',
         version: '1.0',
@@ -502,7 +640,7 @@ class FetchNetworkCommand extends NetworkCommand {
     }
 }
 
-function buildServiceDescriptor$7() {
+function buildServiceDescriptor$8() {
     return {
         type: 'fetchNetworkCommandBaseClass',
         version: '1.0',
@@ -540,7 +678,7 @@ class StreamingCommand extends BaseCommand {
     }
 }
 
-function buildServiceDescriptor$6() {
+function buildServiceDescriptor$7() {
     return {
         type: 'streamingCommandBaseClass',
         version: '1.0',
@@ -656,7 +794,7 @@ class SSEParsingStream extends TransformStream {
     }
 }
 
-function buildServiceDescriptor$5() {
+function buildServiceDescriptor$6() {
     return {
         type: 'SSECommandBaseClass',
         version: '1.0',
@@ -706,7 +844,7 @@ function buildInstrumentCommand(services) {
     };
 }
 
-function buildServiceDescriptor$4(instrumentation) {
+function buildServiceDescriptor$5(instrumentation) {
     return {
         type: 'instrumentCommand',
         version: '1.0',
@@ -960,7 +1098,7 @@ class O11yInstrumentation {
         this.metrics = new O11yOTelMetricsAPI(this.services);
     }
 }
-function buildServiceDescriptor$3(logger) {
+function buildServiceDescriptor$4(logger) {
     return {
         type: 'instrumentation',
         version: '1.0',
@@ -1042,6 +1180,7 @@ class DefaultRecordableCache {
         this.keysRead = new KeySetImpl();
         this.missingKeysRead = new KeySetImpl();
         this.keysUpdated = new KeySetImpl();
+        this.metadataKeysUpdated = new KeySetImpl();
     }
     delete(key) {
         this.keysUpdated.add(key);
@@ -1060,8 +1199,13 @@ class DefaultRecordableCache {
     }
     set(key, value) {
         this.keysUpdated.add(key);
+        this.metadataKeysUpdated.add(key);
         this.baseCache.set(key, value);
     }
+    setMetadata(key, cacheControlMetadata) {
+        this.metadataKeysUpdated.add(key);
+        this.baseCache.setMetadata(key, cacheControlMetadata);
+    }
     length() {
         return this.baseCache.length();
     }
@@ -1103,6 +1247,9 @@ class DefaultFilteredCache {
     set(key, value) {
         this.baseCache.set(key, value);
     }
+    setMetadata(key, cacheControlMetadata) {
+        this.baseCache.setMetadata(key, cacheControlMetadata);
+    }
     length() {
         return this.getFilteredKeys().length;
     }
@@ -1163,6 +1310,18 @@ class DefaultCache {
     delete(key) {
         delete this.data[key];
     }
+    /**
+     * Sets the metadata for the specified key if the key is in cache.
+     * If the key doesn't exist, it does nothing.
+     *
+     * @param key key at which to store metadata
+     * @param cacheControlMetadata metadata to be stored
+     */
+    setMetadata(key, cacheControlMetadata) {
+        if (key in this.data) {
+            this.data[key].metadata.cacheControl = cacheControlMetadata;
+        }
+    }
     length() {
         return this.keys().length;
     }
@@ -1180,7 +1339,7 @@ class DefaultCache {
     }
 }
 
-function buildServiceDescriptor$2() {
+function buildServiceDescriptor$3() {
     return {
         type: 'cache',
         version: '1.0',
@@ -1283,7 +1442,7 @@ class CacheController {
     }
 }
 
-function buildServiceDescriptor$1(cache) {
+function buildServiceDescriptor$2(cache) {
     return {
         type: 'cacheController',
         version: '1.0',
@@ -1291,6 +1450,75 @@ function buildServiceDescriptor$1(cache) {
     };
 }
 
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+
+const EventTypeWildcard = Symbol('EventTypeWildcard');
+
+/**
+ * A simple implementation of PubSubService.
+ */
+class DefaultPubSubService {
+    constructor() {
+        this.subscriptions = new Map();
+    }
+    subscribe(subscription) {
+        let eventTypeSubscriptions = this.subscriptions.get(subscription.type);
+        if (eventTypeSubscriptions === undefined) {
+            eventTypeSubscriptions = [];
+            this.subscriptions.set(subscription.type, eventTypeSubscriptions);
+        }
+        eventTypeSubscriptions.push(subscription);
+        return () => {
+            this.subscriptions.set(subscription.type, eventTypeSubscriptions.filter((value) => value !== subscription));
+        };
+    }
+    publish(event) {
+        const eventTypeSubscriptions = this.subscriptions.get(event.type);
+        const wildcardSubscriptions = this.subscriptions.get(EventTypeWildcard);
+        if (eventTypeSubscriptions === undefined && wildcardSubscriptions === undefined) {
+            return resolvedPromiseLike(undefined);
+        }
+        let matchingSubscriptions = [];
+        if (eventTypeSubscriptions !== undefined) {
+            matchingSubscriptions = eventTypeSubscriptions.filter((subscription) => {
+                if (subscription.predicate) {
+                    return subscription.predicate(event);
+                }
+                return true;
+            });
+        }
+        matchingSubscriptions = [...matchingSubscriptions, ...(wildcardSubscriptions || [])];
+        const promises = [];
+        matchingSubscriptions.forEach((subscription) => {
+            const returnVal = subscription.callback(event);
+            if (isPromiseLike(returnVal)) {
+                promises.push(returnVal);
+            }
+        });
+        if (promises.length > 0) {
+            return Promise.all(promises).then(() => undefined);
+        }
+        return resolvedPromiseLike(undefined);
+    }
+}
+/**
+ * Constructs a default PubSubService
+ *
+ * @returns default PubSubServiceDescriptor
+ */
+function buildServiceDescriptor$1() {
+    return {
+        type: 'pubSub',
+        version: '1.0',
+        service: new DefaultPubSubService(),
+    };
+}
+
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
  * All rights reserved.
@@ -1841,7 +2069,7 @@ var TypeCheckShapes;
     TypeCheckShapes[TypeCheckShapes["Integer"] = 3] = "Integer";
     TypeCheckShapes[TypeCheckShapes["Unsupported"] = 4] = "Unsupported";
 })(TypeCheckShapes || (TypeCheckShapes = {}));
-// engine version: 0.156.5-f5fd8c7a
+// engine version: 0.156.6-042d5d87
 
 const { keys: keys$1 } = Object;
 
@@ -4790,7 +5018,7 @@ function getEnvironmentSetting(name) {
     }
     return undefined;
 }
-// version: 1.344.0-455da7ef74
+// version: 1.346.0-1b813009ec
 
 const forceRecordTransactionsDisabled = getEnvironmentSetting(EnvironmentSettings.ForceRecordTransactionsDisabled);
 //TODO: Some duplication here that can be most likely moved to a util class
@@ -5441,22 +5669,23 @@ function initializeLDS() {
 // Initializes OneStore in LEX
 function initializeOneStore() {
     const loggerService = new ConsoleLogger$1('ERROR');
-    const cacheServiceDescriptor = buildServiceDescriptor$2();
-    const instrumentationServiceDescriptor = buildServiceDescriptor$3(loggerService);
+    const cacheServiceDescriptor = buildServiceDescriptor$3();
+    const instrumentationServiceDescriptor = buildServiceDescriptor$4(loggerService);
     const services = [
         instrumentationServiceDescriptor,
         buildUnauthorizedFetchServiceDescriptor(),
         buildJwtAuthorizedSfapFetchServiceDescriptor(loggerService),
         buildCopilotFetchServiceDescriptor(loggerService),
         buildAuraNetworkService(),
-        buildServiceDescriptor$4(instrumentationServiceDescriptor.service),
-        buildServiceDescriptor$1(cacheServiceDescriptor.service),
-        buildServiceDescriptor$9(),
-        buildServiceDescriptor$7(),
+        buildServiceDescriptor$5(instrumentationServiceDescriptor.service),
+        buildServiceDescriptor$2(cacheServiceDescriptor.service),
         buildServiceDescriptor$a(),
-        buildServiceDescriptor$6(),
-        buildServiceDescriptor$5(),
         buildServiceDescriptor$8(),
+        buildServiceDescriptor$b(),
+        buildServiceDescriptor$7(),
+        buildServiceDescriptor$6(),
+        buildServiceDescriptor$9(),
+        buildServiceDescriptor$1(),
     ];
     setServices(services);
 }
@@ -5479,4 +5708,4 @@ function ldsEngineCreator() {
 }
 
 export { LexRequestStrategy, PdlRequestPriority, buildPredictorForContext, ldsEngineCreator as default, initializeLDS, initializeOneStore, registerRequestStrategy, saveRequestAsPrediction, unregisterRequestStrategy, whenPredictionsReady };
-// version: 1.344.0-5dd845c684
+// version: 1.346.0-43bf38de66

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-runtime-aura",
-    "version": "1.344.0",
+    "version": "1.346.0",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "LDS engine for Aura runtime",
     "main": "dist/ldsEngineCreator.js",
@@ -34,43 +34,44 @@
         "release:corejar": "yarn build && ../core-build/scripts/core.js --name=lds-runtime-aura"
     },
     "devDependencies": {
-        "@luvio/service-provisioner": "5.27.1",
-        "@salesforce/lds-adapters-apex": "^1.344.0",
-        "@salesforce/lds-adapters-uiapi": "^1.344.0",
+        "@luvio/service-provisioner": "5.29.0",
+        "@salesforce/lds-adapters-apex": "^1.346.0",
+        "@salesforce/lds-adapters-uiapi": "^1.346.0",
         "@salesforce/lds-adapters-uiapi-lex": "^1.302.0",
-        "@salesforce/lds-ads-bridge": "^1.344.0",
-        "@salesforce/lds-aura-storage": "^1.344.0",
-        "@salesforce/lds-bindings": "^1.344.0",
-        "@salesforce/lds-instrumentation": "^1.344.0",
-        "@salesforce/lds-network-aura": "^1.344.0",
-        "@salesforce/lds-network-fetch": "^1.344.0",
+        "@salesforce/lds-ads-bridge": "^1.346.0",
+        "@salesforce/lds-aura-storage": "^1.346.0",
+        "@salesforce/lds-bindings": "^1.346.0",
+        "@salesforce/lds-instrumentation": "^1.346.0",
+        "@salesforce/lds-network-aura": "^1.346.0",
+        "@salesforce/lds-network-fetch": "^1.346.0",
         "jwt-encode": "1.0.1"
     },
     "dependencies": {
-        "@luvio/command-aura-network": "5.27.1",
-        "@luvio/command-aura-resource-cache-control": "5.27.1",
-        "@luvio/command-fetch-network": "5.27.1",
-        "@luvio/command-network": "5.27.1",
-        "@luvio/command-sse": "5.27.1",
-        "@luvio/command-streaming": "5.27.1",
-        "@luvio/network-adapter-composable": "0.156.5",
-        "@luvio/network-adapter-fetch": "0.156.5",
-        "@luvio/service-aura-network": "5.27.1",
-        "@luvio/service-cache": "5.27.1",
-        "@luvio/service-cache-control": "5.27.1",
-        "@luvio/service-fetch-network": "5.27.1",
-        "@luvio/service-instrument-command": "5.27.1",
-        "@luvio/service-store": "5.27.1",
-        "@luvio/utils": "5.27.1",
-        "@salesforce/lds-adapters-uiapi-lex": "^1.344.0"
+        "@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/network-adapter-composable": "0.156.6",
+        "@luvio/network-adapter-fetch": "0.156.6",
+        "@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.346.0"
     },
     "luvioBundlesize": [
         {
             "path": "./dist/ldsEngineCreator.js",
             "maxSize": {
-                "none": "207 kB",
-                "min": "86 kB",
-                "compressed": "36.5 kB"
+                "none": "215 kB",
+                "min": "89 kB",
+                "compressed": "38 kB"
             }
         }
     ],