@salesforce/lds-runtime-aura 1.428.0-dev20 → 1.428.0-dev21

package/dist/ldsEngineCreator.js

@@ -2763,7 +2763,7 @@ function buildServiceDescriptor$d(luvio) {
         },
     };
 }
-// version: 1.428.0-dev20-d72ac06681
+// version: 1.428.0-dev21-133a7da4f5
 
 /*!
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -3116,7 +3116,7 @@ function buildServiceDescriptor$9(notifyRecordUpdateAvailable, getNormalizedLuvi
         },
     };
 }
-// version: 1.428.0-dev20-d72ac06681
+// version: 1.428.0-dev21-133a7da4f5
 
 /*!
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -5992,7 +5992,7 @@ function getEnvironmentSetting(name) {
     }
     return undefined;
 }
-// version: 1.428.0-dev20-d72ac06681
+// version: 1.428.0-dev21-133a7da4f5
 
 const environmentHasAura = typeof window !== 'undefined' && typeof window.$A !== 'undefined';
 const defaultConfig = {
@@ -7354,6 +7354,27 @@ function buildJwtParameterizationInterceptor(jwtManager, jwtRequestModifier = (_
 }
 
 const SFAP_BASE_URL = 'api.salesforce.com';
+// The fetch-service tag the Data360 (direct-to-Data Cloud) custom command binds
+// to. Distinct from SFAP's `sfap_api` so the Data360 host-rewrite interceptor only
+// ever runs for that command — zero blast radius on the SFAP fleet.
+//
+// The tag is deliberately named after the *mechanism* (the `cdp_url` host rewrite),
+// not a capability, because this whole descriptor is interim: it exists only while
+// the mint service returns the fixed SFAP `baseUri` regardless of platform. When the
+// service returns the correct per-platform `baseUri`, the data 360 route can be re-evaluated.
+// This mechanism is NOT intended to be re-used outside of this initial context.
+// This is a client-side routing key only.
+const DATA_360_CDP_URL_REWRITE_AUTH_SCOPE = 'data_360_cdp_url_rewrite';
+// The minted-JWT claim carrying the Data Cloud tenant-specific endpoint (TSE).
+// The server's `SFAPJwtClaimHandlerImpl` emits it for CDP-provisioned orgs as a
+// verbatim passthrough of `DataCloudTenant.getApiEndpoint()` — no normalization.
+// The exact FORM therefore varies and must not be assumed: it may be a bare host
+// (`<hash>.c360a.salesforce.com`) or a full URL with scheme
+// (`https://a360.cdp.<region>.aws.sfdc.cl`), and the suffix is cloud-dependent
+// (commercial `.salesforce.com`, substrate `.aws.sfdc.cl`, GovCloud
+// `.salesforce.mil`). This is why the interceptor strips any scheme before parsing
+// and applies no host-suffix policy — see the interceptor docblock's trust boundary.
+const CDP_URL_CLAIM = 'cdp_url';
 function buildDispatchingSfapJwtResolver(legacyResolver, parameterizedResolver) {
     return {
         getJwt(params) {
@@ -7397,6 +7418,46 @@ function buildJwtAuthorizedSfapFetchServiceDescriptor(logger) {
         tags: { authenticationScopes: 'sfap_api' },
     };
 }
+/**
+ * Returns a service descriptor for the **direct-to-Data360** custom command
+ * (CDP Query v3, host `*.c360a.salesforce.com`).
+ *
+ * Unlike SFAP, the per-tenant base host is NOT returned in the mint response's
+ * `baseUri` (which is the fixed SFAP host); it rides on the minted JWT as the
+ * `cdp_url` claim. The standard `JwtRequestModifier` only receives `extraInfo`,
+ * never the decoded claims, so the host rewrite cannot be expressed as a modifier
+ * — it must read the token directly. This descriptor therefore uses a bespoke
+ * interceptor ({@link buildData360HostRewriteInterceptor}) that mints the
+ * parameterized SFAP JWT, attaches the Bearer token, decodes `cdp_url`, and
+ * rewrites the request host to that TSE.
+ *
+ * It reuses the module's `sfapJwtManager`: `cdp_url` is emitted on the same
+ * `SFAP_API`-scope JWT, so the Data360 command mints the same kind of token — it
+ * just forwards the data-cloud scopes via the context-seed `jwtMintParams`.
+ *
+ * Gated behind its own `data_360_cdp_url_rewrite` auth-scope tag so it binds ONLY to
+ * the Data360 command — the SFAP fleet never flows past this interceptor.
+ */
+function buildJwtAuthorizedData360FetchServiceDescriptor(logger) {
+    const data360FetchService = buildServiceDescriptor$2({
+        createContext: createInstrumentationIdContext(),
+        request: [
+            buildThirdPartyTrackerRegisterInterceptor(),
+            buildData360HostRewriteInterceptor(logger),
+            // Compression runs LAST, after the host-rewrite interceptor has minted,
+            // attached the Bearer token, and rewritten the URL — so it only ever sees
+            // the final request body. It is a strict pass-through: bodies that are
+            // missing, non-string, or under the 1KB threshold flow through untouched,
+            // preserving the tuple (URL + Authorization header) the rewrite produced.
+            buildCompressionInterceptor({ algorithm: 'gzip' }),
+        ],
+        finally: [buildThirdPartyTrackerFinishInterceptor()],
+    });
+    return {
+        ...data360FetchService,
+        tags: { authenticationScopes: DATA_360_CDP_URL_REWRITE_AUTH_SCOPE },
+    };
+}
 /**
  * Returns a service descriptor for a fetch service that includes one-off copilot
  * hacks. This fetch service is not intended for use by anything other than
@@ -7497,6 +7558,75 @@ function buildSfapJwtRequestModifier(logger) {
 function buildJwtRequestInterceptor(logger) {
     return buildJwtRequestHeaderInterceptor(sfapJwtManager, buildSfapJwtRequestModifier(logger));
 }
+/**
+ * Request interceptor for the direct-to-Data360 command. It cannot use the
+ * standard `JwtRequestModifier` seam because the tenant host is a JWT *claim*
+ * (`cdp_url`), and modifiers only receive `extraInfo`. So — like the copilot
+ * interceptor that reads `decodedInfo.iss` — it holds the token directly:
+ *
+ *   1. Read the command's `jwtMintParams` off the per-request context seed and
+ *      mint (via the parameterized SFAP resolver, routed by the dispatching
+ *      resolver inside `sfapJwtManager`). Without mint params there is no token
+ *      to authorize with, so leave the request untouched.
+ *   2. Decode `cdp_url` from the JWT and resolve the tenant-specific endpoint
+ *      (TSE). `cdp_url` is a bare host, so a scheme is prepended before parsing
+ *      and the protocol is forced to `https:`.
+ *   3. Only after a usable `cdp_url` is confirmed, attach `Authorization: Bearer
+ *      <jwt>` and rewrite the request URL's host/protocol to the TSE.
+ *
+ * **Trust boundary.** `cdp_url` is a claim on a first-party, server-minted JWT
+ * delivered over the same-origin Aura transport, so the interceptor does NOT police
+ * its contents (no host-suffix or format allowlist) — the routing host is the
+ * minting service's responsibility, and this mirrors the SFAP sibling, which
+ * likewise trusts the server-provided `baseUri` rewrite target. The one guard that
+ * remains is shape hygiene: if `cdp_url` is absent/empty/non-string (org not
+ * CDP-provisioned, so the server's claim gate did not fire) the interceptor throws
+ * a developer-facing error instead of an opaque parse failure. A minted token is
+ * never attached until a usable host is in hand.
+ */
+function buildData360HostRewriteInterceptor(logger) {
+    return (fetchArgs, context) => {
+        const mintParams = context?.[JWT_MINT_PARAMS_SEED_KEY];
+        // No mint params → not a parameterized Data360 request. Nothing to do.
+        if (mintParams === undefined) {
+            return resolvedPromiseLike$2(fetchArgs);
+        }
+        return resolvedPromiseLike$2(sfapJwtManager.getJwt(mintParams)).then((token) => {
+            const [resource, request] = fetchArgs;
+            if (typeof resource !== 'string' && !(resource instanceof URL)) {
+                // istanbul ignore else: not exercised under NODE_ENV=production
+                if (process.env.NODE_ENV !== 'production') {
+                    throw new Error('Data360 fetch service expects a string or URL resource');
+                }
+                return fetchArgs;
+            }
+            const cdpUrl = token.decodedInfo?.[CDP_URL_CLAIM];
+            // Require a non-empty string. This is shape hygiene, NOT a content
+            // policy: the routing host is the minting service's responsibility, and
+            // we deliberately do not couple to its contents (no host-suffix/format
+            // check — the SFAP sibling likewise trusts its server-provided rewrite
+            // target). We only confirm we were handed a usable host string; a
+            // missing/empty/non-string claim (org not Data Cloud provisioned, so the
+            // server's claim gate did not fire) fails with a clear error rather than
+            // an opaque `new URL` TypeError. The `typeof` check also narrows `cdpUrl`
+            // to `string` for the `.replace` below.
+            if (typeof cdpUrl !== 'string' || cdpUrl.length === 0) {
+                logger.warn(`Data360 fetch service: minted JWT has no usable "${CDP_URL_CLAIM}" claim. The org may not be Data Cloud provisioned.`);
+                // eslint-disable-next-line @salesforce/lds/no-error-in-production
+                throw new Error(`Data360 fetch service: minted JWT has no usable "${CDP_URL_CLAIM}" claim; cannot route the request to a Data Cloud tenant endpoint.`);
+            }
+            // `cdp_url` is a bare host (no scheme); prepend https so `new URL`
+            // parses it as an origin. Force https regardless of any scheme in the
+            // claim — the TSE is always TLS.
+            const tse = new URL(`https://${cdpUrl.replace(/^[a-z]+:\/\//i, '')}`);
+            const authorizedArgs = setHeaderAuthorization(token, [resource, request]);
+            const url = typeof resource === 'string' ? new URL(resource) : new URL(resource.toString());
+            url.host = tse.host;
+            url.protocol = 'https:';
+            return [url, authorizedArgs[1]];
+        });
+    };
+}
 /**
  * Wraps the legacy `buildJwtRequestHeaderInterceptor` with a pass-through guard:
  * when the parameterized interceptor has already authorized the request (an
@@ -10904,6 +11034,7 @@ function initializeOneStore(luvio) {
         buildLexRuntimeDefaultFetchServiceDescriptor(loggerService, retryService),
         buildUnauthorizedFetchServiceDescriptor(),
         buildJwtAuthorizedSfapFetchServiceDescriptor(loggerService),
+        buildJwtAuthorizedData360FetchServiceDescriptor(loggerService),
         buildCopilotFetchServiceDescriptor(loggerService),
         buildAuraNetworkService(),
         buildServiceDescriptor$j(instrumentationServiceDescriptor.service),
@@ -10958,4 +11089,4 @@ function ldsEngineCreator() {
 }
 
 export { LexRequestStrategy, PdlPrefetcherEventType, PdlRequestPriority, buildPredictorForContext, configService, ldsEngineCreator as default, initializeLDS, initializeOneStore, notifyUpdateAvailableFactory, registerRequestStrategy, saveRequestAsPrediction, subscribeToPrefetcherEvents, unregisterRequestStrategy, whenPredictionsReady };
-// version: 1.428.0-dev20-1b319a0432
+// version: 1.428.0-dev21-c9faba50c9

package/dist/types/fetch-service-descriptors/jwt-authorized-fetch-service.d.ts

@@ -5,6 +5,27 @@ import { type LoggerService } from '@conduit-client/utils';
 export declare function buildDispatchingSfapJwtResolver(legacyResolver: JwtResolver<ExtraInfo>, parameterizedResolver: JwtResolver<ExtraInfo>): JwtResolver<ExtraInfo>;
 export declare function prefetchSfapJwt(): Promise<undefined>;
 export declare function buildJwtAuthorizedSfapFetchServiceDescriptor(logger: LoggerService): FetchServiceDescriptor;
+/**
+ * Returns a service descriptor for the **direct-to-Data360** custom command
+ * (CDP Query v3, host `*.c360a.salesforce.com`).
+ *
+ * Unlike SFAP, the per-tenant base host is NOT returned in the mint response's
+ * `baseUri` (which is the fixed SFAP host); it rides on the minted JWT as the
+ * `cdp_url` claim. The standard `JwtRequestModifier` only receives `extraInfo`,
+ * never the decoded claims, so the host rewrite cannot be expressed as a modifier
+ * — it must read the token directly. This descriptor therefore uses a bespoke
+ * interceptor ({@link buildData360HostRewriteInterceptor}) that mints the
+ * parameterized SFAP JWT, attaches the Bearer token, decodes `cdp_url`, and
+ * rewrites the request host to that TSE.
+ *
+ * It reuses the module's `sfapJwtManager`: `cdp_url` is emitted on the same
+ * `SFAP_API`-scope JWT, so the Data360 command mints the same kind of token — it
+ * just forwards the data-cloud scopes via the context-seed `jwtMintParams`.
+ *
+ * Gated behind its own `data_360_cdp_url_rewrite` auth-scope tag so it binds ONLY to
+ * the Data360 command — the SFAP fleet never flows past this interceptor.
+ */
+export declare function buildJwtAuthorizedData360FetchServiceDescriptor(logger: LoggerService): FetchServiceDescriptor;
 /**
  * Returns a service descriptor for a fetch service that includes one-off copilot
  * hacks. This fetch service is not intended for use by anything other than

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-runtime-aura",
-    "version": "1.428.0-dev20",
+    "version": "1.428.0-dev21",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "LDS engine for Aura runtime",
     "main": "dist/ldsEngineCreator.js",
@@ -36,14 +36,14 @@
     "devDependencies": {
         "@conduit-client/service-provisioner": "3.19.0-dev3",
         "@conduit-client/tools-core": "3.19.0-dev3",
-        "@salesforce/lds-adapters-apex": "^1.428.0-dev20",
-        "@salesforce/lds-adapters-uiapi": "^1.428.0-dev20",
-        "@salesforce/lds-ads-bridge": "^1.428.0-dev20",
-        "@salesforce/lds-aura-storage": "^1.428.0-dev20",
-        "@salesforce/lds-bindings": "^1.428.0-dev20",
-        "@salesforce/lds-instrumentation": "^1.428.0-dev20",
-        "@salesforce/lds-network-aura": "^1.428.0-dev20",
-        "@salesforce/lds-network-fetch": "^1.428.0-dev20",
+        "@salesforce/lds-adapters-apex": "^1.428.0-dev21",
+        "@salesforce/lds-adapters-uiapi": "^1.428.0-dev21",
+        "@salesforce/lds-ads-bridge": "^1.428.0-dev21",
+        "@salesforce/lds-aura-storage": "^1.428.0-dev21",
+        "@salesforce/lds-bindings": "^1.428.0-dev21",
+        "@salesforce/lds-instrumentation": "^1.428.0-dev21",
+        "@salesforce/lds-network-aura": "^1.428.0-dev21",
+        "@salesforce/lds-network-fetch": "^1.428.0-dev21",
         "jwt-encode": "1.0.1"
     },
     "dependencies": {
@@ -75,11 +75,11 @@
         "@luvio/network-adapter-composable": "0.160.4-dev1",
         "@luvio/network-adapter-fetch": "0.160.4-dev1",
         "@lwc/state": "^0.29.0",
-        "@salesforce/lds-adapters-onestore-graphql": "^1.428.0-dev20",
+        "@salesforce/lds-adapters-onestore-graphql": "^1.428.0-dev21",
         "@salesforce/lds-adapters-uiapi-lex": "^1.415.0",
-        "@salesforce/lds-durable-storage": "^1.428.0-dev20",
-        "@salesforce/lds-luvio-service": "^1.428.0-dev20",
-        "@salesforce/lds-luvio-uiapi-records-service": "^1.428.0-dev20"
+        "@salesforce/lds-durable-storage": "^1.428.0-dev21",
+        "@salesforce/lds-luvio-service": "^1.428.0-dev21",
+        "@salesforce/lds-luvio-uiapi-records-service": "^1.428.0-dev21"
     },
     "luvioBundlesize": [
         {
@@ -87,7 +87,7 @@
             "maxSize": {
                 "none": "410 kB",
                 "min": "190 kB",
-                "compressed": "71 kB"
+                "compressed": "71.5 kB"
             }
         }
     ],