@faststore/core 4.5.0-dev.3 → 4.5.0-dev.5

package/src/sdk/localization/useBindingSelector.ts

@@ -9,8 +9,86 @@ import {
   isValidUrl,
   resolveBinding,
 } from './bindingSelector'
+import type { LocalizedProductLocale } from './LocalizedProductContext'
 import type { BindingSelectorError, Locale } from './types'
 
+const OTHER_LOCALES_STORAGE_PREFIX = 'fs:otherLocales:'
+
+/**
+ * Extracts the SKU id from a PDP-shaped pathname ("/.../{slug}-{skuId}/p").
+ * Slugs always end with "-{skuId}" (see `getSlug` in the API), so the id is the
+ * last "-"-separated segment of the path segment that precedes "/p".
+ * Returns null when the path is not a product page or has no numeric id.
+ */
+export function getSkuIdFromPdpPath(pathname: string): string | null {
+  const match = pathname.match(/\/([^/]+)\/p\/?$/) // NOSONAR
+  const skuId = match?.[1]?.split('-').pop()
+
+  return skuId && /^\d+$/.test(skuId) ? skuId : null
+}
+
+/**
+ * Persists the localized slug map for a product keyed by its SKU id. This lets
+ * the locale selector rebuild canonical localized product URLs even after the
+ * user lands on a context-less page (e.g. a 404 for a locale where the product
+ * is unavailable), where `otherLocales` is no longer provided by the page.
+ */
+export function persistOtherLocales(
+  otherLocales: LocalizedProductLocale[]
+): void {
+  if (typeof window === 'undefined' || !otherLocales.length) return
+
+  const skuId = otherLocales[0]?.slug.split('-').pop()
+  if (!skuId) return
+
+  try {
+    globalThis.sessionStorage.setItem(
+      `${OTHER_LOCALES_STORAGE_PREFIX}${skuId}`,
+      JSON.stringify(otherLocales)
+    )
+  } catch {
+    // sessionStorage may be unavailable (private mode/quota); non-critical.
+  }
+}
+
+function isLocalizedProductLocaleArray(
+  value: unknown
+): value is LocalizedProductLocale[] {
+  return (
+    Array.isArray(value) &&
+    value.every(
+      (item) =>
+        typeof item === 'object' &&
+        item !== null &&
+        typeof (item as Record<string, unknown>).locale === 'string' &&
+        typeof (item as Record<string, unknown>).slug === 'string'
+    )
+  )
+}
+
+/**
+ * Recovers a previously persisted localized slug map for the product referenced
+ * by the current PDP URL. Returns null when not on a PDP or nothing is stored.
+ */
+export function recoverOtherLocales(): LocalizedProductLocale[] | null {
+  if (typeof window === 'undefined') return null
+
+  const skuId = getSkuIdFromPdpPath(globalThis.location.pathname)
+  if (!skuId) return null
+
+  try {
+    const raw = globalThis.sessionStorage.getItem(
+      `${OTHER_LOCALES_STORAGE_PREFIX}${skuId}`
+    )
+
+    if (!raw) return null
+    const parsed: unknown = JSON.parse(raw)
+    return isLocalizedProductLocaleArray(parsed) ? parsed : null
+  } catch {
+    return null
+  }
+}
+
 interface Currency {
   code: string
   name: string
@@ -64,9 +142,17 @@ export interface UseBindingSelectorReturn {
  * Hook that provides state and actions for the localization selector.
  * Manages locale selection, currency filtering, and binding resolution.
  *
+ * @param otherLocales - Optional list of localized slugs for the current page.
+ *   When provided (e.g. on PDP or PLP), the save action navigates to the
+ *   localized page URL instead of preserving the current page path verbatim.
+ * @param urlSuffix - Suffix appended after the slug when building the redirect URL.
+ *   Use '/p' for product pages (default) and '' for collection/PLP pages.
  * @returns Object with languages, currencies, selections, and actions
  */
-export function useBindingSelector(): UseBindingSelectorReturn {
+export function useBindingSelector(
+  otherLocales?: Array<{ locale: string; slug: string }> | null,
+  urlSuffix = '/p'
+): UseBindingSelectorReturn {
   const { locale: currentLocale, currency: currentCurrency } = useSession()
   const localizationConfig = storeConfig.localization as LocalizationConfig
 
@@ -96,6 +182,15 @@ export function useBindingSelector(): UseBindingSelectorReturn {
     }
   }, [currentCurrency?.code])
 
+  // Persist the product's localized slugs so a later locale switch can rebuild
+  // the canonical localized URL even from a context-less page (e.g. a 404).
+  // Only relevant on PDPs — PLP otherLocales are collection slugs, not products.
+  useEffect(() => {
+    if (urlSuffix === '/p' && otherLocales?.length) {
+      persistOtherLocales(otherLocales)
+    }
+  }, [otherLocales, urlSuffix])
+
   // Build language options with disambiguation - returns Record<localeCode, languageName>
   const languages = useMemo(
     () => buildLanguageOptions(localizationConfig.locales),
@@ -181,12 +276,60 @@ export function useBindingSelector(): UseBindingSelectorReturn {
       return
     }
 
-    // Redirect to binding URL, preserving the current page path and query string
-    window.location.href = buildRedirectUrl(
+    // Prefer the current page's localized slugs. When missing (e.g. we're on a
+    // 404 for a locale where the product is unavailable) recover the map that was
+    // persisted while on a working PDP, so we can still build the canonical
+    // localized product URL instead of dropping the user on the locale home.
+    const effectiveOtherLocales = otherLocales?.length
+      ? otherLocales
+      : recoverOtherLocales()
+
+    if (effectiveOtherLocales?.length) {
+      // 1. Target locale has a specific translation → use it
+      const localizedEntry = effectiveOtherLocales.find(
+        (e) => e.locale === localeCode
+      )
+
+      // 2. No translation for target locale → fall back to the default locale slug
+      //    (IS linkText, always in the default locale) to avoid carrying over a
+      //    translated slug from a different locale (e.g. Italian slug on es-ES).
+      //    For an unavailable target this yields a 404 at the product URL (expected).
+      const fallbackEntry = effectiveOtherLocales.find(
+        (e) => e.locale === localizationConfig.defaultLocale
+      )
+
+      const entry = localizedEntry ?? fallbackEntry
+
+      if (entry) {
+        const baseUrl = binding.url.replace(/\/$/, '')
+        globalThis.location.href = `${baseUrl}/${entry.slug}${urlSuffix}${globalThis.location.search}${globalThis.location.hash}`
+        return
+      }
+    }
+
+    // otherLocales is empty/null but we're still on a PDP: strip the stale slug.
+    if (globalThis.location.pathname.endsWith('/p')) {
+      globalThis.location.href = binding.url
+      return
+    }
+
+    // No localized slugs available (not even persisted): preserve the current
+    // page path under the target binding instead of dropping the user on the
+    // locale home. For a default-locale slug this resolves the product; for an
+    // unavailable/untranslated slug it yields a 404 at the product URL, never the
+    // locale root.
+    globalThis.location.href = buildRedirectUrl(
       binding.url,
-      `${window.location.pathname}${window.location.search}${window.location.hash}`
+      `${globalThis.location.pathname}${globalThis.location.search}${globalThis.location.hash}`
     )
-  }, [localeCode, currencyCode, localizationConfig.locales])
+  }, [
+    localeCode,
+    currencyCode,
+    localizationConfig.locales,
+    localizationConfig.defaultLocale,
+    otherLocales,
+    urlSuffix,
+  ])
 
   const isSaveEnabled = Boolean(localeCode && currencyCode && !error)
 

package/src/sdk/offer/index.ts

@@ -5,7 +5,7 @@ import { fetcher } from './fetcher'
 import { bestOfferFirst } from './sort'
 export { getUrl as getOfferUrl } from './fetcher'
 
-const ERROR_DATA = { offers: {}, isValidating: false }
+const ERROR_DATA = { offers: {}, priceToken: null, isValidating: false }
 
 export function useOffer(args: { skuId: string }) {
   const { data, error, isValidating } = useSWR(args.skuId, fetcher)
@@ -41,5 +41,10 @@ export function useOffer(args: { skuId: string }) {
 
   const offers = aggregateOffer(sellers)
 
-  return { offers, isValidating }
+  // Fresh Pricing Fallback signed price token from the best seller. Fetched
+  // directly from Intelligent Search on the client, so it bypasses the SSG/CDN
+  // caches and respects the token's short (~30min) validity window.
+  const priceToken = sellers[0]?.PriceToken ?? null
+
+  return { offers, priceToken, isValidating }
 }

package/src/server/index.ts

@@ -34,6 +34,7 @@ interface ExecuteOptions<V = Record<string, unknown>> {
   operation: Operation
   variables: V
   query?: string | null
+  locale?: string
 }
 
 const persistedQueries = new Map()
@@ -98,7 +99,7 @@ export const execute = async <V extends Maybe<{ [key: string]: unknown }>, D>(
     cookies: Map<string, Record<string, string>> | null
   }
 }> => {
-  const { operation, variables, query: maybeQuery } = options
+  const { operation, variables, query: maybeQuery, locale } = options
   const { operationHash, operationName } = operation['__meta__']
 
   if (!persistedQueries.size) {
@@ -127,6 +128,14 @@ export const execute = async <V extends Maybe<{ [key: string]: unknown }>, D>(
 
   const contextValue = await contextFactory(envelopContext)
 
+  // Override the store-default locale with the per-request locale (if any) so
+  // localization-aware resolvers read it from ctx.storage.locale. Resolvers that
+  // carry their own locale (e.g. product/search via locator facets) still
+  // override this default inside their own resolution.
+  if (locale) {
+    contextValue.storage.locale = locale
+  }
+
   const { data, errors } = (await run({
     schema,
     document: parse(query),

package/test/sdk/localization/useBindingSelector.test.tsx

@@ -1,4 +1,4 @@
-import { describe, expect, it } from 'vitest'
+import { afterEach, describe, expect, it, vi } from 'vitest'
 
 import {
   buildLanguageOptions,
@@ -6,7 +6,47 @@ import {
   isValidUrl,
   resolveBinding,
 } from '../../../src/sdk/localization/bindingSelector'
+import type { LocalizedProductLocale } from '../../../src/sdk/localization/LocalizedProductContext'
 import type { Locale } from '../../../src/sdk/localization/types'
+import {
+  getSkuIdFromPdpPath,
+  persistOtherLocales,
+  recoverOtherLocales,
+} from '../../../src/sdk/localization/useBindingSelector'
+
+/** In-memory Storage stub matching the subset used by the helpers. */
+function createFakeStorage() {
+  const map = new Map<string, string>()
+
+  return {
+    getItem: (key: string) => (map.has(key) ? (map.get(key) as string) : null),
+    setItem: (key: string, value: string) => {
+      map.set(key, value)
+    },
+    removeItem: (key: string) => {
+      map.delete(key)
+    },
+    clear: () => map.clear(),
+  }
+}
+
+/**
+ * Stubs a browser-like global scope with the given pathname and storage.
+ *
+ * The production helpers guard on `typeof window` but read `globalThis.location`
+ * / `globalThis.sessionStorage` (which coincide with `window` in a real browser).
+ * Under the node test environment those are distinct, so we stub all three: the
+ * `window` keeps the guard passing while `location`/`sessionStorage` back the reads.
+ * Pass an existing `sessionStorage` to simulate navigation while storage persists.
+ */
+function stubWindow(pathname: string, sessionStorage = createFakeStorage()) {
+  const location = { pathname }
+  vi.stubGlobal('window', { location, sessionStorage })
+  vi.stubGlobal('location', location)
+  vi.stubGlobal('sessionStorage', sessionStorage)
+
+  return sessionStorage
+}
 
 // Test data that mirrors what the hook would receive from discovery.config
 const mockLocales: Record<string, Locale> = {
@@ -216,4 +256,107 @@ describe('useBindingSelector integration scenarios', () => {
       expect(newCurrencies[0]).toBe('EUR')
     })
   })
+
+  describe('getSkuIdFromPdpPath', () => {
+    afterEach(() => {
+      vi.unstubAllGlobals()
+    })
+
+    it('extracts the SKU id from a locale-prefixed PDP path', () => {
+      expect(
+        getSkuIdFromPdpPath(
+          '/en-CA/adidas-mens-performance-polo-blast-blue-65/p'
+        )
+      ).toBe('65')
+    })
+
+    it('extracts the SKU id from a default-locale (root) PDP path', () => {
+      expect(
+        getSkuIdFromPdpPath('/adidas-mens-performance-polo-blast-blue-65/p')
+      ).toBe('65')
+    })
+
+    it('extracts the SKU id from a custom-path binding PDP', () => {
+      expect(getSkuIdFromPdpPath('/europe/it/some-product-slug-12/p')).toBe(
+        '12'
+      )
+    })
+
+    it('handles a trailing slash after /p', () => {
+      expect(getSkuIdFromPdpPath('/pt-BR/some-slug-9/p/')).toBe('9')
+    })
+
+    it('returns null for non-PDP paths', () => {
+      expect(getSkuIdFromPdpPath('/en-CA')).toBeNull()
+      expect(getSkuIdFromPdpPath('/en-CA/office')).toBeNull()
+      expect(getSkuIdFromPdpPath('/')).toBeNull()
+    })
+
+    it('returns null when the slug has no numeric id', () => {
+      expect(getSkuIdFromPdpPath('/en-CA/no-numeric-id/p')).toBeNull()
+    })
+  })
+
+  describe('persist / recover otherLocales (sessionStorage)', () => {
+    afterEach(() => {
+      vi.unstubAllGlobals()
+    })
+
+    const otherLocales: LocalizedProductLocale[] = [
+      { locale: 'en-US', slug: 'adidas-mens-performance-polo-blast-blue-65' },
+      {
+        locale: 'pt-BR',
+        slug: 'adidas-polo-performance-masculina-azul-blast-65',
+      },
+      {
+        locale: 'fr-CA',
+        slug: 'adidas-polo-performance-homme-bleu-blast-ca-65',
+      },
+    ]
+
+    it('round-trips the map for the SKU referenced by the current path', () => {
+      // Persisted while on a working PDP (SKU 65).
+      const storage = stubWindow(
+        '/adidas-mens-performance-polo-blast-blue-65/p'
+      )
+      persistOtherLocales(otherLocales)
+
+      // Later, on a 404 for en-CA (same SKU 65, default-locale slug in the URL).
+      stubWindow('/en-CA/adidas-mens-performance-polo-blast-blue-65/p', storage)
+
+      expect(recoverOtherLocales()).toEqual(otherLocales)
+    })
+
+    it('returns null when the current path references a different SKU', () => {
+      const storage = stubWindow(
+        '/adidas-mens-performance-polo-blast-blue-65/p'
+      )
+      persistOtherLocales(otherLocales)
+
+      stubWindow('/en-CA/some-other-product-99/p', storage)
+
+      expect(recoverOtherLocales()).toBeNull()
+    })
+
+    it('returns null when the current path is not a PDP', () => {
+      const storage = stubWindow(
+        '/adidas-mens-performance-polo-blast-blue-65/p'
+      )
+      persistOtherLocales(otherLocales)
+
+      stubWindow('/en-CA', storage)
+
+      expect(recoverOtherLocales()).toBeNull()
+    })
+
+    it('does not persist when otherLocales is empty', () => {
+      const storage = stubWindow(
+        '/adidas-mens-performance-polo-blast-blue-65/p'
+      )
+      persistOtherLocales([])
+
+      expect(recoverOtherLocales()).toBeNull()
+      expect(storage.getItem('fs:otherLocales:65')).toBeNull()
+    })
+  })
 })