@conduit-client/salesforce-lightning-service-worker 3.6.3 → 3.7.0-dev1

package/dist/index.js

@@ -50,7 +50,7 @@ function isPromiseLike(x) {
  * All rights reserved.
  * For full license text, see the LICENSE.txt file
  */
-function buildServiceDescriptor(interceptors = {
+function buildServiceDescriptor$1(interceptors = {
   request: [],
   retry: void 0,
   response: [],
@@ -76,6 +76,9 @@ function buildServiceDescriptor(interceptors = {
         if (retryInterceptor) {
           return retryInterceptor(args2, retryService, context);
         } else {
+          if (retryService) {
+            return retryService.applyRetry(() => fetch(...args2));
+          }
           return fetch(...args2);
         }
       }).then((response) => {
@@ -94,119 +97,234 @@ function buildServiceDescriptor(interceptors = {
     }
   };
 }
-const CACHE_VERSION = 1;
-const CACHE_NAME = `salesforce-lightning-service-worker-${CACHE_VERSION}`;
-const CSRF_HEADER = "X-CSRF-Token";
-const API_PATH_PREFIX = "/services/data/v";
-async function withCache(callback) {
-  if (caches) {
-    const cache = await caches.open(CACHE_NAME);
-    return callback(cache);
+function setHeader(headerName, headerValue, [resource, options = {}], {
+  throwOnExisting = false,
+  errorMessage = `Unexpected ${headerName} header encountered`
+} = {}) {
+  let hasHeaderBeenSet = false;
+  if (resource instanceof Request && !(options == null ? void 0 : options.headers)) {
+    if (throwOnExisting && resource.headers.has(headerName)) {
+      throw new Error(errorMessage);
+    }
+    resource.headers.set(headerName, headerValue);
+    hasHeaderBeenSet = true;
+  }
+  if ((options == null ? void 0 : options.headers) instanceof Headers) {
+    if (throwOnExisting && options.headers.has(headerName)) {
+      throw new Error(errorMessage);
+    }
+    options.headers.set(headerName, headerValue);
   } else {
-    return void 0;
+    if (throwOnExisting && (options == null ? void 0 : options.headers) && Reflect.has(options.headers, headerName)) {
+      throw new Error(errorMessage);
+    }
+    if (!hasHeaderBeenSet) {
+      options.headers = {
+        ...options == null ? void 0 : options.headers,
+        [headerName]: headerValue
+      };
+    }
+  }
+  return [resource, options];
+}
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+class RetryService {
+  constructor(defaultRetryPolicy) {
+    this.defaultRetryPolicy = defaultRetryPolicy;
   }
+  applyRetry(operation, retryPolicyOverride) {
+    return this.retry(operation, retryPolicyOverride || this.defaultRetryPolicy);
+  }
+  async retry(operation, policy) {
+    const startTime = Date.now();
+    let attempt = 0;
+    let result = await operation();
+    let context = {
+      attempt,
+      totalElapsedMs: Date.now() - startTime,
+      lastResult: result
+    };
+    while (await policy.shouldRetry(result, context)) {
+      const delay = await policy.calculateDelay(result, context);
+      await this.delay(delay);
+      if (policy.prepareRetry) {
+        await policy.prepareRetry(result, context);
+      }
+      attempt++;
+      result = await operation();
+      context = {
+        attempt,
+        totalElapsedMs: Date.now() - startTime,
+        lastResult: result
+      };
+    }
+    return result;
+  }
+  delay(ms) {
+    return new Promise((resolve) => {
+      setTimeout(resolve, ms);
+    });
+  }
+}
+class RetryPolicy {
+}
+function buildServiceDescriptor(defaultRetryPolicy) {
+  return {
+    version: "1.0",
+    service: new RetryService(defaultRetryPolicy),
+    type: "retry"
+  };
+}
+const HEADER = "X-CSRF-Token";
+function buildInterceptor$1(csrfTokenManager, config = {}) {
+  const { protectedUrls = [] } = config;
+  return async (fetchArgs) => {
+    const [input, init] = fetchArgs;
+    const request = new Request(input, init);
+    if (isProtectedMethod(request.method) && isProtectedUrl(protectedUrls, request.url) && !request.headers.has(HEADER)) {
+      const token = await csrfTokenManager.getToken();
+      fetchArgs = setHeader(HEADER, token, fetchArgs);
+    }
+    return resolvedPromiseLike(fetchArgs);
+  };
 }
 function isProtectedMethod(method) {
   const normalizedMethod = method.toLowerCase();
   return normalizedMethod === "post" || normalizedMethod === "put" || normalizedMethod === "patch" || normalizedMethod === "delete";
 }
-function isProtectedUrl(urlString) {
+function isProtectedUrl(protectedUrls, urlString) {
   const url = new URL(urlString);
-  return url.pathname.includes(API_PATH_PREFIX);
+  return protectedUrls.some((protectedUrl) => url.pathname.includes(protectedUrl));
+}
+function buildInterceptor(csrfTokenManager, config = {}) {
+  const headerInterceptor = buildInterceptor$1(csrfTokenManager, config);
+  async function makeRequest(fetchArgs) {
+    const args = await headerInterceptor(fetchArgs);
+    return fetch(...args);
+  }
+  return (fetchArgs, retryService) => {
+    if (!retryService) {
+      return makeRequest(fetchArgs);
+    }
+    return retryService.applyRetry(async () => {
+      return makeRequest(fetchArgs);
+    });
+  };
 }
-async function isTokenInvalid(response) {
+class CsrfTokenRetryPolicy extends RetryPolicy {
+  constructor(csrfTokenManager) {
+    super(csrfTokenManager);
+    this.csrfTokenManager = csrfTokenManager;
+  }
+  /**
+   * Determines if a failed request should be retried due to CSRF token issues.
+   */
+  async shouldRetry(result, context) {
+    if (context.attempt >= 1) {
+      return false;
+    }
+    if (result.status !== 400) {
+      return false;
+    }
+    return await isCsrfError(result);
+  }
+  /**
+   * CSRF token refresh should happen immediately with no delay.
+   */
+  async calculateDelay(_result, _context) {
+    return 0;
+  }
+  /**
+   * Called by retry service before each retry attempt.
+   *
+   * @param _result - The failed response that triggered the retry (unused, already validated)
+   * @param _context - Current retry context (unused but part of interface)
+   */
+  async prepareRetry(_result, _context) {
+    await this.csrfTokenManager.refreshToken();
+  }
+}
+async function isCsrfError(response) {
   var _a;
-  if (response.status === 400) {
+  try {
     const body = await response.clone().json();
     return ((_a = body[0]) == null ? void 0 : _a.errorCode) === "INVALID_ACCESS_TOKEN";
+  } catch {
+    return false;
   }
-  return false;
 }
-function createLightningFetch(config = {}) {
-  const { fireEvent = () => {
-  }, csrfTokenSource, interceptors } = config;
-  const { service: fetchService } = buildServiceDescriptor(interceptors);
-  let tokenUrl = `${API_PATH_PREFIX}65.0/ui-api/session/csrf`;
-  let tokenProvider = obtainToken;
-  if (csrfTokenSource) {
-    if (typeof csrfTokenSource === "string" || csrfTokenSource instanceof URL) {
-      tokenUrl = csrfTokenSource;
-    } else if (typeof csrfTokenSource === "function") {
-      tokenProvider = csrfTokenSource;
-    }
+class CsrfTokenManager {
+  constructor(endpoint, cacheName) {
+    this.endpoint = endpoint;
+    this.cacheName = cacheName;
+    this.tokenPromise = this.obtainToken();
   }
-  function generateId() {
-    return Date.now().toString(36);
+  /**
+   * Returns the current token value as a Promise.
+   * Lazy-loads the token on first call (from cache or by fetching).
+   */
+  async getToken() {
+    return this.tokenPromise;
+  }
+  /**
+   * Obtains and returns a new token value as a promise.
+   * This will clear the cached token and fetch a fresh one.
+   */
+  async refreshToken() {
+    await this.withCache((cache) => cache.delete(this.endpoint));
+    this.tokenPromise = this.obtainToken();
+    return this.tokenPromise;
   }
-  async function obtainToken() {
-    const id = generateId();
-    fireEvent("csrf_token_obtain_start", id);
-    let response = await withCache((cache) => cache.match(tokenUrl));
+  /**
+   * Obtains a CSRF token, using cache when available or fetching a new one.
+   *
+   * @returns Promise that resolves to the CSRF token string
+   */
+  async obtainToken() {
+    let response = await this.withCache((cache) => cache.match(this.endpoint));
+    let cacheMiss = false;
     if (!response) {
-      fireEvent("csrf_token_fetch_start", id);
-      response = await fetchService(tokenUrl, { method: "get" });
-      fireEvent("csrf_token_fetch_complete", id, { status: response.status });
-    } else {
-      fireEvent("csrf_token_cache_hit", id);
+      response = await fetch(this.endpoint, { method: "get" });
+      cacheMiss = true;
     }
     const csrfToken = (await response.clone().json()).csrfToken;
-    await withCache((cache) => cache.put(tokenUrl, response));
-    fireEvent("csrf_token_obtain_complete", id);
-    return csrfToken;
-  }
-  let tokenPromise = tokenProvider();
-  async function refreshToken() {
-    const id = generateId();
-    fireEvent("csrf_token_refresh_start", id);
-    await withCache((cache) => cache.delete(tokenUrl));
-    tokenPromise = tokenProvider();
-    fireEvent("csrf_token_refresh_complete", id);
-  }
-  async function fetchWithToken(request) {
-    const headers = new Headers(request.headers);
-    if (!headers.has(CSRF_HEADER)) {
-      headers.set(CSRF_HEADER, await tokenPromise);
+    if (cacheMiss) {
+      await this.withCache((cache) => cache.put(this.endpoint, response));
     }
-    return fetchService(request, { headers });
+    return csrfToken;
   }
-  return async function lightningFetch(input, init) {
-    const id = generateId();
-    const request = new Request(input, init);
-    if (isProtectedMethod(request.method) && isProtectedUrl(request.url)) {
-      fireEvent("protected_request_start", id, { method: request.method, url: request.url });
-      const response = await fetchWithToken(request.clone());
-      if (await isTokenInvalid(response)) {
-        fireEvent("csrf_token_invalid", id, { status: response.status });
-        await refreshToken();
-        const retryResponse = await fetchWithToken(request.clone());
-        fireEvent("protected_request_complete", id, {
-          method: request.method,
-          url: request.url,
-          status: retryResponse.status,
-          retried: true
-        });
-        return retryResponse;
-      } else {
-        fireEvent("protected_request_complete", id, {
-          method: request.method,
-          url: request.url,
-          status: response.status,
-          retried: false
-        });
-        return response;
-      }
+  /**
+   * Provides a safe way to interact with the Cache API with fallback for unsupported environments.
+   *
+   * @param callback - Function that receives the cache instance and returns a promise
+   * @returns The result of the callback, or undefined if caches API is not available
+   */
+  async withCache(callback) {
+    if (this.cacheName && caches) {
+      const cache = await caches.open(this.cacheName);
+      return callback(cache);
     } else {
-      fireEvent("unprotected_request", id, { method: request.method, url: request.url });
-      return fetchService(request);
+      return void 0;
     }
-  };
+  }
+}
+function createFetchService(config) {
+  const csrfConfig = config.csrf;
+  const csrfTokenManager = new CsrfTokenManager(csrfConfig.endpoint, csrfConfig.cacheName);
+  return buildServiceDescriptor$1(
+    { retry: buildInterceptor(csrfTokenManager, csrfConfig) },
+    buildServiceDescriptor(new CsrfTokenRetryPolicy(csrfTokenManager)).service
+  ).service;
 }
-let clientFetch = createLightningFetch();
+let clientFetch;
 let serviceWorkerLoading = false;
 let pendingRequests = [];
+let instance;
 class ConduitClient {
-  constructor() {
-  }
   /**
    * Makes an HTTP request
    *
@@ -220,45 +338,94 @@ class ConduitClient {
         pendingRequests.push({ input, init, resolve });
       });
     }
-    return clientFetch(input, init);
+    return Promise.resolve(clientFetch(input, init));
   }
   /**
-   * Factory method to create a new ConduitClient instance
+   * Configures global settings for all ConduitClient instances.
+   * This will recreate the internal fetch service with the new configuration.
    *
-   * @returns A new ConduitClient instance
+   * @param config - Configuration options for CSRF handling and other features
    */
-  static create() {
-    return new ConduitClient();
+  static initialize(config) {
+    if (instance) {
+      throw new Error("ConduitClient.initialize can only be called once");
+    }
+    instance = new ConduitClient();
+    if (config.serviceWorkerUrl) {
+      return registerServiceWorker(config);
+    } else {
+      clientFetch = createFetchService(config);
+      return Promise.resolve();
+    }
   }
   /**
-   * Registers a service worker for enhanced CSRF protection and caching.
-   * When successfully registered, the client will switch to using native fetch
-   * as the service worker will handle CSRF protection.
+   * Factory method to create a new ConduitClient instance
    *
-   * @param scriptURL - path to the service worker script
+   * @returns A new ConduitClient instance
    */
-  static async registerServiceWorker(scriptURL) {
-    if ("serviceWorker" in navigator) {
-      try {
-        serviceWorkerLoading = true;
-        const registration = await navigator.serviceWorker.register(scriptURL, {
-          type: "classic"
-        });
-        clientFetch = fetch;
-        console.log("[Conduit Client] Service registration succeeded:", registration);
-      } catch (error) {
-        console.log(
-          "[Conduit Client] Service Worker registration failed (using decorated `fetch`):",
-          error
-        );
-      } finally {
-        processQueuedRequests();
+  static instance() {
+    if (!instance) {
+      throw new Error("ConduitClient.initialize must be called first");
+    }
+    return instance;
+  }
+}
+async function registerServiceWorker(config) {
+  if ("serviceWorker" in navigator) {
+    try {
+      serviceWorkerLoading = true;
+      const registration = await navigator.serviceWorker.register(config.serviceWorkerUrl, {
+        type: "classic"
+      });
+      clientFetch = fetch;
+      console.log("[Conduit Client] Service registration succeeded:", registration);
+      if (registration.active) {
+        await postConfigToServiceWorker(registration.active, config);
+      } else if (registration.waiting || registration.installing) {
+        const serviceWorker = registration.waiting || registration.installing;
+        await waitForServiceWorkerActive(serviceWorker);
+        if (registration.active) {
+          await postConfigToServiceWorker(registration.active, config);
+        }
       }
-    } else {
-      console.log("[Conduit Client] Service Worker not supported (using decorated `fetch`):");
+    } catch (error) {
+      console.log(
+        "[Conduit Client] Service Worker registration failed (using decorated `fetch`):",
+        error
+      );
+    } finally {
+      processQueuedRequests();
     }
+  } else {
+    console.log("[Conduit Client] Service Worker not supported (using decorated `fetch`):");
+  }
+}
+async function postConfigToServiceWorker(serviceWorker, config) {
+  try {
+    const { serviceWorkerUrl, ...configData } = config;
+    serviceWorker.postMessage({
+      type: "fetch-config",
+      config: configData
+    });
+  } catch (error) {
+    console.warn("[Conduit Client] Failed to post config to service worker:", error);
   }
 }
+function waitForServiceWorkerActive(serviceWorker) {
+  return new Promise((resolve) => {
+    if (serviceWorker.state === "activated") {
+      resolve();
+      return;
+    }
+    function handleStateChange() {
+      if (serviceWorker.state === "activated") {
+        serviceWorker.removeEventListener("statechange", handleStateChange);
+        resolve();
+      }
+    }
+    serviceWorker.addEventListener("statechange", handleStateChange);
+  });
+}
 function processQueuedRequests() {
   serviceWorkerLoading = false;
   pendingRequests.forEach(({ input, init, resolve }) => {