@salesforce/lds-network-fetch 1.436.0 → 1.438.0

package/dist/ldsNetworkFetch.js

@@ -62,7 +62,9 @@ var HttpStatusCode;
     HttpStatusCode[HttpStatusCode["Unauthorized"] = 401] = "Unauthorized";
     HttpStatusCode[HttpStatusCode["Forbidden"] = 403] = "Forbidden";
     HttpStatusCode[HttpStatusCode["NotFound"] = 404] = "NotFound";
+    HttpStatusCode[HttpStatusCode["TooManyRequests"] = 429] = "TooManyRequests";
     HttpStatusCode[HttpStatusCode["ServerError"] = 500] = "ServerError";
+    HttpStatusCode[HttpStatusCode["ServiceUnavailable"] = 503] = "ServiceUnavailable";
     HttpStatusCode[HttpStatusCode["GatewayTimeout"] = 504] = "GatewayTimeout";
 })(HttpStatusCode || (HttpStatusCode = {}));
 /**
@@ -125,7 +127,7 @@ var TypeCheckShapes;
     TypeCheckShapes[TypeCheckShapes["Integer"] = 3] = "Integer";
     TypeCheckShapes[TypeCheckShapes["Unsupported"] = 4] = "Unsupported";
 })(TypeCheckShapes || (TypeCheckShapes = {}));
-// engine version: 0.160.4-b7e0ea82
+// engine version: 0.160.5-e6ada846
 
 const { keys: keys$1 } = Object;
 
@@ -216,11 +218,6 @@ function generateHeaders(headers) {
     return fetchHeaders;
 }
 
-/*!
- * Copyright (c) 2022, Salesforce, Inc.,
- * All rights reserved.
- * For full license text, see the LICENSE.txt file
- */
 function resolvedPromiseLike(result) {
   if (isPromiseLike(result)) {
     return result.then((nextResult) => nextResult);
@@ -256,7 +253,7 @@ function rejectedPromiseLike(reason) {
   };
 }
 function isPromiseLike(x) {
-  return typeof (x == null ? void 0 : x.then) === "function";
+  return typeof x?.then === "function";
 }
 
 /**
@@ -329,6 +326,9 @@ function mergeRecordFields(first, second) {
                 targetFields[fieldName] = sourceFields[fieldName];
                 continue;
             }
+            if (targetField.displayValue === null && sourceField.displayValue !== null) {
+                targetField.displayValue = sourceField.displayValue;
+            }
             mergeRecordFields(targetField.value, sourceField.value);
             continue;
         }
@@ -744,9 +744,15 @@ function getStorageAndLogger(path) {
 }
 const platformFetchAdapter = platformNetworkAdapter(fetchNetworkAdapter);
 const platformFetchAdapterWithInterceptors = async (resourceRequest, resourceRequestContext, requestInterceptors, interceptorContext) => {
-    const pending = requestInterceptors.reduce((previousPromise, interceptor) => previousPromise.then((resourceRequest) => interceptor(resourceRequest, interceptorContext)), resolvedPromiseLike(resourceRequest));
+    const pending = runRequestInterceptors(resourceRequest, requestInterceptors, interceptorContext);
     return pending.then((interceptedRequest) => platformFetchAdapter(interceptedRequest, resourceRequestContext));
 };
+/**
+ * Runs the request interceptor chain on a request and returns the intercepted
+ * request. Exposed so callers (e.g. the retry path) can run interceptors once
+ * up front and then issue the actual network call separately on each attempt.
+ */
+const runRequestInterceptors = (resourceRequest, requestInterceptors, interceptorContext) => requestInterceptors.reduce((previousPromise, interceptor) => previousPromise.then((resourceRequest) => interceptor(resourceRequest, interceptorContext)), resolvedPromiseLike(resourceRequest));
 async function getDurableCacheDataForIncomingRequest(resourceRequest, storageAndLogger, transactionKey) {
     if (!shouldForceRefresh(resourceRequest)) {
         if (storageAndLogger?.storage) {
@@ -795,12 +801,28 @@ async function handleSendFetchRequest(resourceRequest, resourceRequestContext, i
         context.queryParams = resourceRequest.queryParams;
         context.cmp = resourceRequestContext.sourceContext?.tagName || 'none';
     }
-    const { request: requestInterceptors = [], response: responseInterceptors = [], finally: finallyInterceptors = [], } = interceptors;
+    const { request: requestInterceptors = [], retry: retryInterceptor, response: responseInterceptors = [], finally: finallyInterceptors = [], } = interceptors;
     const cachedData = await getDurableCacheDataForIncomingRequest(resourceRequest, storageAndLogger, transactionKey);
     if (cachedData !== undefined) {
         return createOkResponse$1(cachedData);
     }
-    const response = platformFetchAdapterWithInterceptors(resourceRequest, resourceRequestContext, requestInterceptors, context);
+    let response;
+    if (retryInterceptor) {
+        // Run the request interceptor chain ONCE up front, then hand the
+        // intercepted request off to the retry interceptor. The retry
+        // interceptor's `doFetch` goes straight to the network — request
+        // interceptors don't re-run on retry attempts. This mirrors the
+        // OneStore retry pattern (`csrf-retry.ts` calls raw `fetch(...)` on
+        // retry) and avoids re-executing side-effecting interceptors that
+        // assume one-shot invocation per logical request (tracker
+        // registration, perf marks, etc.).
+        const intercepted = await runRequestInterceptors(resourceRequest, requestInterceptors, context);
+        const doFetch = (req) => platformFetchAdapter(req, resourceRequestContext);
+        response = retryInterceptor(intercepted, doFetch, context);
+    }
+    else {
+        response = platformFetchAdapterWithInterceptors(resourceRequest, resourceRequestContext, requestInterceptors, context);
+    }
     const interceptedResponse = Promise.resolve(responseInterceptors.reduce((previousPromise, interceptor) => previousPromise.then((response) => interceptor(response, context)), resolvedPromiseLike(response)));
     // This can probably be refactored once we add an error interceptor pattern to onestore, and then
     // the intial then here can also most likely be moved to a response interceptor as well
@@ -850,4 +872,4 @@ function instrument(newInstrumentation) {
 }
 
 export { instrument, setupFetchNetworkAdapter, setupLexNetworkAdapter };
-// version: 1.436.0-581b8a5964
+// version: 1.438.0-0ec0a89235

package/dist/types/main.d.ts

@@ -1,4 +1,4 @@
 export { setupFetchNetworkAdapter, setupLexNetworkAdapter } from './networkAdapter';
 export type { RequestLogger } from './networkAdapter';
-export type { RequestInterceptor, ResponseInterceptor, Interceptors } from './utils';
+export type { RequestInterceptor, ResponseInterceptor, LuvioRetryInterceptor, Interceptors, } from './utils';
 export { instrument, FetchNetworkInstrumentation } from './instrumentation';

package/dist/types/utils.d.ts

@@ -11,15 +11,40 @@ type LdsStorageConfig = {
  * @returns LdsStorageConfig if we cache that resource, otherwise null.
  */
 export declare function getStorageAndLogger(path: string): LdsStorageConfig | null;
+export declare const platformFetchAdapter: import("@luvio/engine").NetworkAdapter;
 export type RequestInterceptor<Context = any> = (fetchArgs: ResourceRequest, context?: Context) => PromiseLike<ResourceRequest>;
 export type ResponseInterceptor<Context = any> = (response: FetchResponse<any>, context?: Context) => PromiseLike<FetchResponse<any>>;
 export type FinallyInterceptor<Context = any> = (context?: Context) => PromiseLike<void> | void;
+/**
+ * Owns the fetch lifecycle for a single inbound request: it may call `doFetch`
+ * any number of times (e.g. to retry on 429/503 or refresh a CSRF token) and
+ * resolves with the final FetchResponse.
+ *
+ * `request` is the result of running the request interceptor chain ONCE, up
+ * front. `doFetch(req)` issues the network call directly — request
+ * interceptors do NOT run again on retry attempts. The interceptor is
+ * responsible for any per-attempt mutations (e.g. swapping a refreshed CSRF
+ * token onto the request before the next `doFetch`).
+ *
+ * This mirrors the OneStore retry pattern, where retry interceptors call raw
+ * `fetch(...)` directly on retry, and avoids re-executing side-effecting
+ * request interceptors (tracker registration, perf marks) that assume
+ * one-shot invocation per logical request.
+ */
+export type LuvioRetryInterceptor<Context = any> = (request: ResourceRequest, doFetch: (req: ResourceRequest) => Promise<FetchResponse<any>>, context?: Context) => Promise<FetchResponse<any>>;
 export type Interceptors<Context = any> = {
     createContext?: () => Context;
     request?: RequestInterceptor<Context>[];
+    retry?: LuvioRetryInterceptor<Context>;
     response?: ResponseInterceptor<Context>[];
     finally?: FinallyInterceptor<Context>[];
 };
 export declare const platformFetchAdapterWithInterceptors: (resourceRequest: ResourceRequest, resourceRequestContext: ResourceRequestContext, requestInterceptors: RequestInterceptor[], interceptorContext: any) => Promise<FetchResponse<any>>;
+/**
+ * Runs the request interceptor chain on a request and returns the intercepted
+ * request. Exposed so callers (e.g. the retry path) can run interceptors once
+ * up front and then issue the actual network call separately on each attempt.
+ */
+export declare const runRequestInterceptors: (resourceRequest: ResourceRequest, requestInterceptors: RequestInterceptor[], interceptorContext: any) => PromiseLike<ResourceRequest>;
 export declare function getDurableCacheDataForIncomingRequest(resourceRequest: ResourceRequest, storageAndLogger: LdsStorageConfig | null, transactionKey: string): Promise<unknown>;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-network-fetch",
-    "version": "1.436.0",
+    "version": "1.438.0",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "LDS Network Adapter using fetch",
     "main": "dist/ldsNetworkFetch.js",
@@ -34,11 +34,11 @@
         "release:corejar": "yarn build && ../core-build/scripts/core.js --name=lds-network-fetch"
     },
     "dependencies": {
-        "@luvio/engine": "0.160.4",
-        "@luvio/network-adapter-fetch": "0.160.4"
+        "@luvio/engine": "0.160.5",
+        "@luvio/network-adapter-fetch": "0.160.5"
     },
     "devDependencies": {
-        "@salesforce/lds-network-aura": "^1.436.0"
+        "@salesforce/lds-network-aura": "^1.438.0"
     },
     "volta": {
         "extends": "../../package.json"