@envive-ai/react-hooks 0.3.62 → 0.3.63

package/src/services/urlResolverWarmupService/__tests__/urlResolverWarmupService.test.ts

@@ -4,6 +4,7 @@ import { contextSourceAtom, envAtom, enviveConfigAtom } from 'src/atoms/envive/e
 import { featureFlagServiceAtom } from 'src/atoms/org/graphqlConfig';
 import { FeatureFlagService } from 'src/services/featureFlagService';
 import type { EnviveServiceConfig } from 'src/services/enviveConfigService';
+import { type UrlResolverResponse, urlResolverAtom } from 'src/atoms/app/variant';
 import { warmUrlResolver } from '../index';
 
 const { mockResolveUrl } = vi.hoisted(() => ({ mockResolveUrl: vi.fn() }));
@@ -82,4 +83,58 @@ describe('warmUrlResolver', () => {
     expect(getAtomStore().get(featureFlagServiceAtom)).toBeUndefined();
     expect(mockResolveUrl).toHaveBeenCalledTimes(1);
   });
+
+  it('seeds urlResolverAtom from precomputedUrlResolving when its URL matches, skipping resolveUrl', async () => {
+    // The bootstrap-consolidated path: /v1/session/bootstrap already resolved
+    // the URL, so the warm-up must NOT fire a second /v1/url_resolving.
+    const response = {
+      variant_type: 'pdp',
+      specific_details: {},
+      ready: true,
+    } as unknown as UrlResolverResponse;
+    const cleansedUrl = window.location.href.toLowerCase().trim();
+
+    await warmUrlResolver({
+      ...baseParams,
+      env: 'prod',
+      contextSource: 'app',
+      featureFlagService: new FeatureFlagService([]),
+      precomputedUrlResolving: { url: cleansedUrl, response },
+    });
+
+    expect(mockResolveUrl).not.toHaveBeenCalled();
+    expect(getAtomStore().get(urlResolverAtom)[cleansedUrl]).toEqual(response);
+  });
+
+  it('falls back to resolveUrl when the precomputed URL no longer matches (SPA nav during bootstrap)', async () => {
+    // Bootstrap resolved a DIFFERENT URL (a nav happened since) — its result must
+    // NOT be cached under the current URL; resolve the current URL instead.
+    const staleResponse = {
+      variant_type: 'plp',
+      specific_details: {},
+      ready: true,
+    } as unknown as UrlResolverResponse;
+    mockResolveUrl.mockResolvedValue({ variant_type: 'pdp', ready: true });
+
+    await warmUrlResolver({
+      ...baseParams,
+      env: 'prod',
+      contextSource: 'app',
+      featureFlagService: new FeatureFlagService([]),
+      precomputedUrlResolving: { url: 'https://other.example/stale', response: staleResponse },
+    });
+
+    expect(mockResolveUrl).toHaveBeenCalledTimes(1);
+    const cleansedUrl = window.location.href.toLowerCase().trim();
+    expect(getAtomStore().get(urlResolverAtom)[cleansedUrl]).toEqual({
+      variant_type: 'pdp',
+      ready: true,
+    });
+  });
+
+  it('falls back to resolveUrl when precomputedUrlResolving is null (getWidgetConfig path)', async () => {
+    await warmUrlResolver({ ...baseParams, precomputedUrlResolving: null });
+
+    expect(mockResolveUrl).toHaveBeenCalledTimes(1);
+  });
 });

package/src/services/urlResolverWarmupService/index.ts

@@ -19,6 +19,15 @@ export interface WarmUrlResolverParams {
   env?: string;
   contextSource?: string;
   featureFlagService?: FeatureFlagService;
+  // The url_resolving result /v1/session/bootstrap already produced (unified-config
+  // gate ON), paired with the URL it was resolved for. When set AND that URL still
+  // matches the current one, the warm-up seeds urlResolverAtom with it and skips
+  // its own /v1/url_resolving call — the third leg of the 3→1 consolidation. If a
+  // SPA navigation changed the URL since bootstrap ran, the URLs no longer match
+  // and the warm-up falls back to resolveUrl (so a stale variant is never cached
+  // under the new URL). The atom-seeding above still runs either way, so
+  // PageProvider (and any later navigation resolveUrl) sees the same context.
+  precomputedUrlResolving?: { url: string; response: UrlResolverResponse } | null;
 }
 
 /**
@@ -43,6 +52,7 @@ export const warmUrlResolver = async ({
   env,
   contextSource,
   featureFlagService,
+  precomputedUrlResolving,
 }: WarmUrlResolverParams): Promise<void> => {
   try {
     const store = getAtomStore();
@@ -79,7 +89,14 @@ export const warmUrlResolver = async ({
       store.set(resolvedBaseConfigVersionAtom, baseVersion);
     }
 
-    const response = (await CommerceApiClient.resolveUrl(cleansedUrl)) as UrlResolverResponse;
+    // Bootstrap already resolved a URL in the same round trip as the config —
+    // reuse it ONLY when it's still the current URL, so its variant is never
+    // cached under a different key after a SPA navigation. Otherwise resolve the
+    // current URL ourselves (same as the no-precompute path).
+    const response =
+      precomputedUrlResolving && precomputedUrlResolving.url === cleansedUrl
+        ? precomputedUrlResolving.response
+        : ((await CommerceApiClient.resolveUrl(cleansedUrl)) as UrlResolverResponse);
     store.set(urlResolverAtom, { url: cleansedUrl, response });
   } catch (err) {
     // Fail open: PageProvider issues its own resolveUrl call when the cache