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

package/dist/types/csrf/header.interceptor.d.ts

@@ -0,0 +1,12 @@
+import type { RequestInterceptor } from '@conduit-client/service-fetch-network/v1';
+import { CsrfTokenManager } from './token-manager';
+export interface HeaderInterceptorConfig {
+    protectedUrls?: string[];
+}
+/**
+ * Builds a configured interceptor for applying CSRF header to requests
+ *
+ * @param csrfTokenManager
+ * @param config
+ */
+export declare function buildInterceptor(csrfTokenManager: CsrfTokenManager, config?: HeaderInterceptorConfig): RequestInterceptor;

package/dist/types/csrf/retry.interceptor.d.ts

@@ -0,0 +1,7 @@
+import type { FetchParameters } from '@conduit-client/service-fetch-network/v1';
+import { type RetryService } from '@conduit-client/service-retry/v1';
+import { HeaderInterceptorConfig } from './header.interceptor';
+import { CsrfTokenManager } from './token-manager';
+export interface RetryInterceptorConfig extends HeaderInterceptorConfig {
+}
+export declare function buildInterceptor(csrfTokenManager: CsrfTokenManager, config?: RetryInterceptorConfig): (fetchArgs: FetchParameters, retryService?: RetryService<Response>) => Promise<Response>;

package/dist/types/csrf/retry.policy.d.ts

@@ -0,0 +1,37 @@
+import { RetryPolicy, type RetryContext } from '@conduit-client/service-retry/v1';
+import { CsrfTokenManager } from './token-manager';
+/**
+ * Retry policy that handles CSRF token expiration errors.
+ *
+ * When a request fails with a CSRF token error this policy will:
+ * 1. Detect the error condition in shouldRetry
+ * 2. Refresh the CSRF token in prepareRetry hook
+ * 3. Retry the request once (maxRetries = 1)
+ *
+ */
+export declare class CsrfTokenRetryPolicy extends RetryPolicy<Response> {
+    private csrfTokenManager;
+    constructor(csrfTokenManager: CsrfTokenManager);
+    /**
+     * Determines if a failed request should be retried due to CSRF token issues.
+     */
+    shouldRetry(result: Response, context: RetryContext<Response>): Promise<boolean>;
+    /**
+     * CSRF token refresh should happen immediately with no delay.
+     */
+    calculateDelay(_result: Response, _context: RetryContext<Response>): Promise<number>;
+    /**
+     * 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)
+     */
+    prepareRetry(_result: Response, _context: RetryContext<Response>): Promise<void>;
+}
+/**
+ * Helper to check if a response indicates a CSRF token error.
+ *
+ * @param response - The response to check
+ * @returns true if the response indicates a CSRF token error (INVALID_ACCESS_TOKEN)
+ */
+export declare function isCsrfError(response: Response): Promise<boolean>;

package/dist/types/csrf/token-manager.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Manages CSRF token fetching and caching for secure requests.
+ * Implements a singleton pattern to ensure consistent token management across the application.
+ */
+declare class CsrfTokenManager {
+    private endpoint;
+    private cacheName?;
+    private tokenPromise;
+    constructor(endpoint: string, cacheName?: string | undefined);
+    /**
+     * Returns the current token value as a Promise.
+     * Lazy-loads the token on first call (from cache or by fetching).
+     */
+    getToken(): Promise<string>;
+    /**
+     * Obtains and returns a new token value as a promise.
+     * This will clear the cached token and fetch a fresh one.
+     */
+    refreshToken(): Promise<string | undefined>;
+    /**
+     * Obtains a CSRF token, using cache when available or fetching a new one.
+     *
+     * @returns Promise that resolves to the CSRF token string
+     */
+    private obtainToken;
+    /**
+     * 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
+     */
+    private withCache;
+}
+export { CsrfTokenManager };

package/dist/types/fetch.d.ts

@@ -1,31 +1,19 @@
-import { Interceptors } from '@conduit-client/service-fetch-network/v1';
-/**
- * Configuration options for the Lightning fetch creation.
- */
-export interface LightningFetchConfig {
-    interceptors?: Interceptors<void>;
-    /**
-     * Optional source for CSRF tokens. Can be:
-     * - string: URL path to token endpoint (e.g., '/custom/csrf-endpoint')
-     * - URL: Full URL object for token endpoint
-     * - function: Custom async function that returns a token string
-     *
-     * As a string or URL, default fetching and caching (if Cache API is
-     * available) will be used to obtain tokens
-     */
-    csrfTokenSource?: string | URL | (() => Promise<string>);
-    /**
-     * Optional callback for firing events related to fetch operations.
-     * Can be used for instrumentation, logging, and monitoring.
-     */
-    fireEvent?: (eventName: string, id: string, data?: unknown) => void;
+import { FetchService } from '@conduit-client/service-fetch-network/v1';
+import { RetryInterceptorConfig } from './csrf/retry.interceptor';
+interface CsrfConfig extends RetryInterceptorConfig {
+    endpoint: string;
+    cacheName: string;
+}
+export interface FetchConfig {
+    csrf: CsrfConfig;
 }
 /**
  * Creates an enhanced fetch function with automatic CSRF token handling.
  * The returned function automatically adds CSRF tokens to protected requests
  * and handles token refresh when tokens become invalid.
  *
- * @param config - Optional configuration object
+ * @param config - Optional configuration for CSRF handling
  * @returns An enhanced fetch function that handles CSRF protection
  */
-export declare function createLightningFetch(config?: LightningFetchConfig): typeof fetch;
+export declare function createFetchService(config: FetchConfig): FetchService;
+export {};

package/dist/types/index.d.ts

@@ -1,3 +1,7 @@
+import { FetchConfig } from './fetch';
+type ConduitClientConfig = {
+    serviceWorkerUrl?: string;
+} & FetchConfig;
 /**
  * A client for making HTTP requests with CSRF protection.  By default, protection is provided by
  * wrapping the native `fetch` API with functionality that will apply a CSRF token to appropriate
@@ -8,7 +12,6 @@
  * to `registerServiceWorker` and `defineServiceWorker`
  */
 export declare class ConduitClient {
-    private constructor();
     /**
      * Makes an HTTP request
      *
@@ -18,17 +21,17 @@ export declare class ConduitClient {
      */
     fetch(input: string | URL | Request, init?: RequestInit): Promise<Response>;
     /**
-     * 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(): ConduitClient;
+    static initialize(config: ConduitClientConfig): Promise<void>;
     /**
-     * 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 registerServiceWorker(scriptURL: string): Promise<void>;
+    static instance(): ConduitClient;
 }
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@conduit-client/salesforce-lightning-service-worker",
-    "version": "3.6.3",
+    "version": "3.7.0",
     "private": false,
     "description": "Service worker for accessing Salesforce data",
     "type": "module",
@@ -32,7 +32,7 @@
         "watch": "npm run build --watch"
     },
     "dependencies": {
-        "@conduit-client/service-fetch-network": "3.6.3"
+        "@conduit-client/service-fetch-network": "3.7.0"
     },
     "volta": {
         "extends": "../../../package.json"
@@ -40,7 +40,7 @@
     "size-limit": [
         {
             "path": "dist/index.js",
-            "limit": "2.82 kB"
+            "limit": "3.14 kB"
         }
     ]
 }