@salesforce/lds-runtime-aura 1.351.1 → 1.353.0

package/dist/ldsEngineCreator.js

@@ -40,48 +40,6 @@ import { createStorage, clearStorages } from 'force/ldsStorage';
 import useHttpInsteadAuraTransport from '@salesforce/gate/lds.useHttpInsteadAuraTransport';
 import { ThirdPartyTracker } from 'instrumentation:beaconLib';
 
-/**
- * Copyright (c) 2022, Salesforce, Inc.,
- * All rights reserved.
- * For full license text, see the LICENSE.txt file
- */
-
-/**
- * BaseCommand is an abstract implementation of SubscribableCommand. It adds the
- * notions of typed configuration, request context, and a set of runtime services
- * to the contract defined by Command/SubscribableCommand.
- */
-class BaseCommand {
-}
-
-/**
- * Copyright (c) 2022, Salesforce, Inc.,
- * All rights reserved.
- * For full license text, see the LICENSE.txt file
- */
-
-
-/**
- * An implementation of BaseCommand that makes network requests but does not try to
- * use the store.
- */
-class NetworkCommand extends BaseCommand {
-    constructor(services) {
-        super();
-        this.services = services;
-    }
-    execute() {
-        return this.fetch();
-    }
-}
-function buildServiceDescriptor$d() {
-    return {
-        type: 'networkCommandBaseClass',
-        version: '1.0',
-        service: NetworkCommand,
-    };
-}
-
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
  * All rights reserved.
@@ -159,6 +117,26 @@ class Err {
 }
 const ok = (value) => new Ok(value);
 const err = (err) => new Err(err);
+function isSubscribableResult(x) {
+    if (typeof x !== 'object' || x === null) {
+        return false;
+    }
+    if ('isOk' in x && typeof x.isOk === 'function') {
+        if (x.isOk()) {
+            return ('value' in x &&
+                typeof x.value === 'object' &&
+                x.value !== null &&
+                'subscribe' in x.value &&
+                typeof x.value.subscribe === 'function' &&
+                'refresh' in x.value &&
+                typeof x.value.refresh === 'function');
+        }
+        else {
+            return 'error' in x;
+        }
+    }
+    return false;
+}
 
 /**
  * Returns a PromiseLike object that resolves with the specified result.
@@ -358,6 +336,89 @@ var HttpStatusCode$2;
     HttpStatusCode[HttpStatusCode["GatewayTimeout"] = 504] = "GatewayTimeout";
 })(HttpStatusCode$2 || (HttpStatusCode$2 = {}));
 
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+/**
+ * BaseCommand is an abstract implementation of SubscribableCommand. It adds the
+ * notions of typed configuration, request context, and a set of runtime services
+ * to the contract defined by Command/SubscribableCommand.
+ */
+class BaseCommand {
+}
+
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+
+/**
+ * An implementation of BaseCommand that makes network requests but does not try to
+ * use the store.
+ */
+class NetworkCommand extends BaseCommand {
+    constructor(services) {
+        super();
+        this.services = services;
+        this.subscriptions = [];
+        this.exposeSubscribeAndRefresh = false;
+    }
+    execute() {
+        const result = this.fetch();
+        if (this.exposeSubscribeAndRefresh) {
+            return this.fetchSubscribableResult(result);
+        }
+        return result;
+    }
+    fetchSubscribableResult(res) {
+        return res.then((networkResult) => {
+            if (networkResult.isErr()) {
+                return err(networkResult.error);
+            }
+            else {
+                const data = networkResult.value;
+                return ok({
+                    data,
+                    subscribe: (cb) => {
+                        this.subscriptions.push(cb);
+                        return () => {
+                            this.subscriptions = this.subscriptions.filter((cb2) => cb2 !== cb);
+                        };
+                    },
+                    refresh: () => this.refresh(),
+                });
+            }
+        });
+    }
+    refresh() {
+        return this.execute().then((newResult) => {
+            if (newResult.isOk()) {
+                if (isSubscribableResult(newResult)) {
+                    const value = newResult.value;
+                    this.subscriptions.forEach((cb) => {
+                        cb(ok(value.data));
+                    });
+                }
+                return ok(undefined);
+            }
+            return err(newResult.error);
+        });
+    }
+    async afterRequestHooks(_options) { }
+}
+function buildServiceDescriptor$d() {
+    return {
+        type: 'networkCommandBaseClass',
+        version: '1.0',
+        service: NetworkCommand,
+    };
+}
+
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
  * All rights reserved.
@@ -385,17 +446,26 @@ class AuraNetworkCommand extends NetworkCommand {
     convertAuraResponseToData(responsePromise, coerceError) {
         return responsePromise
             .then((response) => {
-            return ok(response.getReturnValue());
+            const auraReturnValue = response.getReturnValue();
+            try {
+                this.afterRequestHooks({ statusCode: 200 }); // Treat all aura success as 200
+            }
+            catch (e) { }
+            return ok(auraReturnValue);
         })
             .catch((error) => {
             if (!error || !error.getError) {
                 return err(toError('Failed to get error from response'));
             }
-            const actionErrors = error.getError();
-            if (actionErrors.length > 0) {
-                return err(coerceError(actionErrors));
+            else {
+                const actionErrors = error.getError();
+                if (actionErrors.length > 0) {
+                    return err(coerceError(actionErrors));
+                }
+                else {
+                    return err(toError('Error fetching component'));
+                }
             }
-            return err(toError('Error fetching component'));
         });
     }
     fetch() {
@@ -429,19 +499,31 @@ class CacheControlCommand extends BaseCommand {
     constructor(services) {
         super();
         this.services = services;
+        this.operationType = 'query';
         this.rebuildUnsubscribe = () => { };
         this.refreshUnsubscribe = () => { };
+        this.lastEmittedData = undefined;
+        this.subscribeToMostRecentKeys = () => undefined;
         this.subscriptions = [];
         this.instantiationTime = Date.now() / 1000; // in seconds
     }
     execute(overrides) {
+        this.subscribeToMostRecentKeys = () => undefined;
         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;
+        return resultPromise.then((result) => {
+            if (this.operationType === 'query') {
+                this.subscribeToMostRecentKeys();
+            }
+            if (result.isOk() && this.lastEmittedData === undefined) {
+                this.lastEmittedData = result.value.data;
+            }
+            return result;
+        });
     }
     // TODO: This should likely be abstract in v2.  For v1, provide default comparison logic.
     equals(result1, result2) {
@@ -454,6 +536,15 @@ class CacheControlCommand extends BaseCommand {
             writeToCache: (networkResult) => this.writeToCacheAndPublish(cache, networkResult),
         };
     }
+    async afterRequestHooks(_options) { }
+    refresh() {
+        return this.rerun({ cacheControlConfig: { type: 'no-cache' } }).then((result) => {
+            if (result.isErr()) {
+                return result;
+            }
+            return ok(undefined);
+        });
+    }
     // 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) {
@@ -478,10 +569,11 @@ class CacheControlCommand extends BaseCommand {
             else {
                 const data = readResult.value;
                 if (data !== undefined) {
-                    this.subscribeToKeys(recordableCache.keysRead, data);
+                    this.subscribeToMostRecentKeys = () => this.subscribeToKeys(recordableCache.keysRead);
                     return ok({
                         data,
                         subscribe: this.buildSubscribe(),
+                        refresh: () => this.refresh(),
                     });
                 }
                 return ok(undefined);
@@ -505,29 +597,36 @@ class CacheControlCommand extends BaseCommand {
             };
         };
     }
-    subscribeToKeys(keysRead, lastResult) {
+    rerun(overrides) {
+        return this.execute(overrides).then((result) => {
+            if (result.isErr()) {
+                this.invokeConsumerCallbacks(result);
+                return result;
+            }
+            if (!this.equals(this.lastEmittedData, result.value.data)) {
+                this.lastEmittedData = result.value.data;
+                this.invokeConsumerCallbacks(ok(result.value.data));
+            }
+            return result;
+        });
+    }
+    subscribeToKeys(keysRead) {
         const { pubSub } = this.services;
         if (!pubSub) {
             return;
         }
-        const executeAndHandleResult = (overrides) => {
-            return this.execute(overrides).then((result) => {
-                if (result.isErr()) {
-                    this.invokeConsumerCallbacks(result);
-                    return;
-                }
-                if (!this.equals(lastResult, result.value.data)) {
-                    this.invokeConsumerCallbacks(ok(result.value.data));
-                }
-            });
-        };
         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());
+        // Unsubscribe to be sure that this command didn't re-execute and re-subscribe in between the start of command execution and now
+        // it shouldn't be possible for this command to resubscribe between the beginning of execution and now
+        // ...but lets be defensive.
+        this.rebuildUnsubscribe();
+        this.refreshUnsubscribe();
+        this.rebuildUnsubscribe = createKeySubscriber('cacheUpdate', () => this.rerun({ now: this.instantiationTime }).then(() => undefined));
+        this.refreshUnsubscribe = createKeySubscriber('cacheInvalidation', () => this.rerun().then(() => undefined));
     }
     invokeConsumerCallbacks(data) {
         this.subscriptions.forEach((cb) => {
@@ -614,17 +713,26 @@ class AuraCacheControlCommand extends CacheControlCommand {
     convertAuraResponseToData(responsePromise, coerceError) {
         return responsePromise
             .then((response) => {
-            return ok(response.getReturnValue());
+            const auraReturnValue = response.getReturnValue();
+            try {
+                this.afterRequestHooks({ statusCode: 200 }); // Treat all aura success as 200
+            }
+            catch (e) { }
+            return ok(auraReturnValue);
         })
             .catch((error) => {
             if (!error || !error.getError) {
                 return err(toError('Failed to get error from response'));
             }
-            const actionErrors = error.getError();
-            if (actionErrors.length > 0) {
-                return err(coerceError(actionErrors));
+            else {
+                const actionErrors = error.getError();
+                if (actionErrors.length > 0) {
+                    return err(coerceError(actionErrors));
+                }
+                else {
+                    return err(toError('Error fetching component'));
+                }
             }
-            return err(toError('Error fetching component'));
         });
     }
 }
@@ -750,10 +858,27 @@ class HttpCacheControlCommand extends CacheControlCommand {
     convertFetchResponseToData(response) {
         return response.then((response) => {
             if (response.ok) {
-                return response.json().then((json) => ok(json), (reason) => err(toError(reason)));
+                return response
+                    .json()
+                    .then((json) => ok(json), (reason) => err(toError(reason)))
+                    .finally(() => {
+                    try {
+                        this.afterRequestHooks({ statusCode: response.status });
+                    }
+                    catch (e) { }
+                });
             }
             else {
-                return this.coerceError(response).then((coercedError) => err(coercedError));
+                return this.coerceError(response)
+                    .then((coercedError) => {
+                    return err(coercedError);
+                })
+                    .finally(() => {
+                    try {
+                        this.afterRequestHooks({ statusCode: response.status });
+                    }
+                    catch (e) { }
+                });
             }
         }, (reason) => err(toError(reason)));
     }
@@ -825,10 +950,27 @@ class FetchNetworkCommand extends NetworkCommand {
     convertFetchResponseToData(response) {
         return response.then((response) => {
             if (response.ok) {
-                return response.json().then((json) => ok(json), (reason) => err(toError(reason)));
+                return response
+                    .json()
+                    .then((json) => ok(json), (reason) => err(toError(reason)))
+                    .finally(() => {
+                    try {
+                        this.afterRequestHooks({ statusCode: response.status });
+                    }
+                    catch (e) { }
+                });
             }
             else {
-                return this.coerceError(response).then((coercedError) => err(coercedError));
+                return this.coerceError(response)
+                    .then((coercedError) => {
+                    return err(coercedError);
+                })
+                    .finally(() => {
+                    try {
+                        this.afterRequestHooks({ statusCode: response.status });
+                    }
+                    catch (e) { }
+                });
             }
         }, (reason) => err(toError(reason)));
     }
@@ -1596,8 +1738,8 @@ class CacheControlStrategy {
         return [
             (cacheControlMetadata) => cacheControlMetadata.type === 'max-age' &&
                 this.config.now > cacheControlMetadata.generatedTime + cacheControlMetadata.maxAge,
-            (cacheControlMetadata) => cacheControlMetadata.type === 'no-cache' ||
-                cacheControlMetadata.type === 'no-store',
+            (cacheControlMetadata) => cacheControlMetadata.type === 'max-age' && cacheControlMetadata.maxAge <= 0,
+            (cacheControlMetadata) => cacheControlMetadata.type === 'no-store',
         ];
     }
 }
@@ -5454,7 +5596,7 @@ function getEnvironmentSetting(name) {
     }
     return undefined;
 }
-// version: 1.351.1-3c191568b9
+// version: 1.353.0-330d59cfcb
 
 const forceRecordTransactionsDisabled = getEnvironmentSetting(EnvironmentSettings.ForceRecordTransactionsDisabled);
 //TODO: Some duplication here that can be most likely moved to a util class
@@ -6146,4 +6288,4 @@ function ldsEngineCreator() {
 }
 
 export { LexRequestStrategy, PdlRequestPriority, buildPredictorForContext, ldsEngineCreator as default, initializeLDS, initializeOneStore, registerRequestStrategy, saveRequestAsPrediction, unregisterRequestStrategy, whenPredictionsReady };
-// version: 1.351.1-fe0298cc85
+// version: 1.353.0-cc9b469dc4

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-runtime-aura",
-    "version": "1.351.1",
+    "version": "1.353.0",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "LDS engine for Aura runtime",
     "main": "dist/ldsEngineCreator.js",
@@ -34,46 +34,47 @@
         "release:corejar": "yarn build && ../core-build/scripts/core.js --name=lds-runtime-aura"
     },
     "devDependencies": {
-        "@luvio/service-provisioner": "5.35.0",
-        "@salesforce/lds-adapters-apex": "^1.351.1",
-        "@salesforce/lds-adapters-uiapi": "^1.351.1",
+        "@luvio/service-provisioner": "5.38.0",
+        "@luvio/tools-core": "5.38.0",
+        "@salesforce/lds-adapters-apex": "^1.353.0",
+        "@salesforce/lds-adapters-uiapi": "^1.353.0",
         "@salesforce/lds-adapters-uiapi-lex": "^1.302.0",
-        "@salesforce/lds-ads-bridge": "^1.351.1",
-        "@salesforce/lds-aura-storage": "^1.351.1",
-        "@salesforce/lds-bindings": "^1.351.1",
-        "@salesforce/lds-instrumentation": "^1.351.1",
-        "@salesforce/lds-network-aura": "^1.351.1",
-        "@salesforce/lds-network-fetch": "^1.351.1",
+        "@salesforce/lds-ads-bridge": "^1.353.0",
+        "@salesforce/lds-aura-storage": "^1.353.0",
+        "@salesforce/lds-bindings": "^1.353.0",
+        "@salesforce/lds-instrumentation": "^1.353.0",
+        "@salesforce/lds-network-aura": "^1.353.0",
+        "@salesforce/lds-network-fetch": "^1.353.0",
         "jwt-encode": "1.0.1"
     },
     "dependencies": {
-        "@luvio/command-aura-network": "5.35.0",
-        "@luvio/command-aura-normalized-cache-control": "5.35.0",
-        "@luvio/command-aura-resource-cache-control": "5.35.0",
-        "@luvio/command-fetch-network": "5.35.0",
-        "@luvio/command-http-normalized-cache-control": "5.35.0",
-        "@luvio/command-network": "5.35.0",
-        "@luvio/command-sse": "5.35.0",
-        "@luvio/command-streaming": "5.35.0",
+        "@luvio/command-aura-network": "5.38.0",
+        "@luvio/command-aura-normalized-cache-control": "5.38.0",
+        "@luvio/command-aura-resource-cache-control": "5.38.0",
+        "@luvio/command-fetch-network": "5.38.0",
+        "@luvio/command-http-normalized-cache-control": "5.38.0",
+        "@luvio/command-network": "5.38.0",
+        "@luvio/command-sse": "5.38.0",
+        "@luvio/command-streaming": "5.38.0",
         "@luvio/network-adapter-composable": "0.156.7",
         "@luvio/network-adapter-fetch": "0.156.7",
-        "@luvio/service-aura-network": "5.35.0",
-        "@luvio/service-cache": "5.35.0",
-        "@luvio/service-cache-control": "5.35.0",
-        "@luvio/service-fetch-network": "5.35.0",
-        "@luvio/service-instrument-command": "5.35.0",
-        "@luvio/service-pubsub": "5.35.0",
-        "@luvio/service-store": "5.35.0",
-        "@luvio/utils": "5.35.0",
-        "@salesforce/lds-adapters-uiapi-lex": "^1.351.1"
+        "@luvio/service-aura-network": "5.38.0",
+        "@luvio/service-cache": "5.38.0",
+        "@luvio/service-cache-control": "5.38.0",
+        "@luvio/service-fetch-network": "5.38.0",
+        "@luvio/service-instrument-command": "5.38.0",
+        "@luvio/service-pubsub": "5.38.0",
+        "@luvio/service-store": "5.38.0",
+        "@luvio/utils": "5.38.0",
+        "@salesforce/lds-adapters-uiapi-lex": "^1.353.0"
     },
     "luvioBundlesize": [
         {
             "path": "./dist/ldsEngineCreator.js",
             "maxSize": {
-                "none": "229.5 kB",
-                "min": "94.7 kB",
-                "compressed": "39.5 kB"
+                "none": "235 kB",
+                "min": "97 kB",
+                "compressed": "40 kB"
             }
         }
     ],