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

package/test/utils/localization/localizeRedirectDestination.test.ts

@@ -0,0 +1,176 @@
+import { describe, expect, it, vi } from 'vitest'
+
+const mockStoreConfig = vi.hoisted(() => ({
+  localization: {
+    enabled: true,
+    defaultLocale: 'en-US',
+    locales: {
+      'en-US': {
+        code: 'en-US',
+        bindings: [
+          {
+            url: 'https://brandless.fast.store/en-US',
+            salesChannel: '1',
+            isDefault: true,
+          },
+        ],
+      },
+      'it-IT': {
+        code: 'it-IT',
+        bindings: [
+          {
+            url: 'https://brandless.fast.store/it-IT',
+            salesChannel: '1',
+            isDefault: true,
+          },
+          {
+            url: 'https://brandless.fast.store/europe/it',
+            salesChannel: '1',
+            isDefault: false,
+          },
+        ],
+      },
+      'en-GB': {
+        code: 'en-GB',
+        bindings: [
+          {
+            url: 'https://brandless.fast.store/emea-eur',
+            salesChannel: '1',
+            isDefault: true,
+          },
+        ],
+      },
+    },
+  },
+}))
+
+vi.mock('../../../discovery.config.js', () => ({
+  default: mockStoreConfig,
+}))
+
+import { localizeRedirectDestination } from '../../../src/utils/localization/localizeRedirectDestination'
+
+const PROFILE = '/pvt/account/profile'
+const ORDERS = '/pvt/account/orders'
+
+describe('localizeRedirectDestination', () => {
+  describe('when localization is disabled', () => {
+    it('returns the destination unchanged', () => {
+      mockStoreConfig.localization.enabled = false
+
+      expect(
+        localizeRedirectDestination(PROFILE, {
+          locale: 'it-IT',
+          defaultLocale: 'en-US',
+          req: { url: '/europe/it/pvt/account' },
+        })
+      ).toBe(PROFILE)
+
+      mockStoreConfig.localization.enabled = true
+    })
+  })
+
+  describe('non-internal destinations', () => {
+    it('leaves external URLs unchanged', () => {
+      expect(
+        localizeRedirectDestination('https://example.com/account', {
+          locale: 'it-IT',
+          defaultLocale: 'en-US',
+        })
+      ).toBe('https://example.com/account')
+    })
+
+    it('leaves protocol-relative URLs unchanged', () => {
+      expect(
+        localizeRedirectDestination('//cdn.example.com/path', {
+          locale: 'it-IT',
+          defaultLocale: 'en-US',
+        })
+      ).toBe('//cdn.example.com/path')
+    })
+  })
+
+  describe('custom binding paths (mirrors resolveLink + addCustomPathPrefix)', () => {
+    it('preserves /emea-eur when the request arrived on that vanity path', () => {
+      expect(
+        localizeRedirectDestination(PROFILE, {
+          locale: 'en-GB',
+          defaultLocale: 'en-US',
+          req: { url: '/emea-eur/pvt/account' },
+        })
+      ).toBe('/emea-eur/pvt/account/profile')
+    })
+
+    it('preserves /europe/it when the request arrived on that vanity path', () => {
+      expect(
+        localizeRedirectDestination(ORDERS, {
+          locale: 'it-IT',
+          defaultLocale: 'en-US',
+          req: { url: '/europe/it/pvt/account/profile' },
+        })
+      ).toBe('/europe/it/pvt/account/orders')
+    })
+
+    it('keeps query strings on the destination', () => {
+      expect(
+        localizeRedirectDestination('/pvt/account/403?from=%2Fpvt%2Faccount', {
+          locale: 'en-GB',
+          defaultLocale: 'en-US',
+          req: { url: '/emea-eur/pvt/account/profile' },
+        })
+      ).toBe('/emea-eur/pvt/account/403?from=%2Fpvt%2Faccount')
+    })
+  })
+
+  describe('Next.js locale-code paths', () => {
+    it('prepends /it-IT when locale is non-default and req.url has no custom prefix', () => {
+      expect(
+        localizeRedirectDestination(PROFILE, {
+          locale: 'it-IT',
+          defaultLocale: 'en-US',
+          req: { url: '/pvt/account' },
+        })
+      ).toBe('/it-IT/pvt/account/profile')
+    })
+
+    it('does not double-prefix when destination already includes the locale', () => {
+      expect(
+        localizeRedirectDestination('/it-IT/pvt/account/profile', {
+          locale: 'it-IT',
+          defaultLocale: 'en-US',
+          req: { url: '/pvt/account' },
+        })
+      ).toBe('/it-IT/pvt/account/profile')
+    })
+  })
+
+  describe('default locale and missing request context', () => {
+    it('returns destination unchanged for the default locale', () => {
+      expect(
+        localizeRedirectDestination(PROFILE, {
+          locale: 'en-US',
+          defaultLocale: 'en-US',
+          req: { url: '/pvt/account' },
+        })
+      ).toBe(PROFILE)
+    })
+
+    it('falls back to locale prefix when req is absent (getStaticProps)', () => {
+      expect(
+        localizeRedirectDestination('/pvt/account/404', {
+          locale: 'it-IT',
+          defaultLocale: 'en-US',
+        })
+      ).toBe('/it-IT/pvt/account/404')
+    })
+
+    it('returns destination unchanged when req is absent and locale is default', () => {
+      expect(
+        localizeRedirectDestination('/pvt/account/404', {
+          locale: 'en-US',
+          defaultLocale: 'en-US',
+        })
+      ).toBe('/pvt/account/404')
+    })
+  })
+})

package/test/sdk/session/installLocaleCorrector.browser.test.ts

@@ -1,208 +0,0 @@
-/**
- * Tests for the localization race-condition fix.
- *
- * The `optimistic` middleware enqueues `onValidate(value)` as a microtask
- * (capturing a `cancel` flag in closure). When the persisted middleware
- * hydrates the store from IDB with a stale locale, the corrector subscriber
- * (installed after `optimistic`) detects the mismatch and re-enters
- * `store.set(corrected)`. The base store cancels in-flight optimistic handlers
- * via `cancelations.forEach(cancel)` BEFORE the stale handler ever runs,
- * preventing the stale `validateSession` from hitting the network.
- *
- * We deliberately skip `persisted` here and simulate IDB hydration by calling
- * `store.set(stale)` directly: persisted's only effect for this test is to
- * trigger that same set() asynchronously, which would only add timing noise.
- */
-import type { Session } from '@faststore/sdk'
-import { compose, createBaseStore, optimistic } from '@faststore/sdk'
-import { describe, expect, it, vi } from 'vitest'
-
-import { installLocaleCorrector } from '../../../src/sdk/session/initialSession'
-
-/**
- * Yields to a macrotask boundary, which guarantees all currently-enqueued
- * microtasks (the `optimistic` middleware's `queue.then(handler)` cascade)
- * have fully drained — including chained continuations from `await` points
- * inside async handlers. More deterministic than a fixed `sleep(N)` and more
- * robust than `await Promise.resolve()` chains (which only drain a fixed
- * number of microtask "generations").
- */
-const flushMicrotasks = () =>
-  new Promise<void>((resolve) => setTimeout(resolve, 0))
-
-const URL_AWARE: Session = {
-  locale: 'pt-BR',
-  currency: { code: 'BRL', symbol: 'R$' },
-  channel: '{"salesChannel":"1","regionId":"region-abc"}',
-  country: 'BRA',
-  deliveryMode: null,
-  addressType: null,
-  city: null,
-  postalCode: null,
-  geoCoordinates: null,
-  b2b: null,
-  person: null,
-  marketingData: null,
-  refreshAfter: null,
-}
-
-const STALE: Session = {
-  ...URL_AWARE,
-  locale: 'en-US',
-  currency: { code: 'USD', symbol: '$' },
-  channel: '{"salesChannel":"2","regionId":"region-xyz"}',
-}
-
-/**
- * NOTE on `onValidate` returning `null`:
- * The `optimistic` middleware re-enters `store.set(validated)` whenever
- * `onValidate` returns a non-null value, which would cause an infinite loop in
- * tests (see `packages/sdk/test/store/optimistic.test.ts` for the same
- * pattern). Returning `null` short-circuits that re-entry while still letting
- * us inspect the arguments the handler was called with.
- */
-function makeStore(initial: Session) {
-  const onValidate = vi.fn(async (_: Session): Promise<Session | null> => null)
-  const store = compose([optimistic(onValidate)], createBaseStore(initial))
-  return { store, onValidate }
-}
-
-describe('installLocaleCorrector', () => {
-  it('cancels stale validation and emits only one with the corrected locale on IDB hydration with stale data', async () => {
-    const { store, onValidate } = makeStore(URL_AWARE)
-    installLocaleCorrector(store, URL_AWARE)
-
-    // Simulates `persisted.hydrateFromIDB` resolving with a stale payload.
-    store.set(STALE)
-    await flushMicrotasks()
-
-    expect(onValidate).toHaveBeenCalledTimes(1)
-    expect(onValidate.mock.calls[0][0].locale).toBe('pt-BR')
-    expect(onValidate.mock.calls[0][0].currency).toEqual({
-      code: 'BRL',
-      symbol: 'R$',
-    })
-
-    // Local store state should also reflect the corrected locale.
-    expect(store.read().locale).toBe('pt-BR')
-  })
-
-  it('preserves unrelated session fields from the hydrated payload (e.g. person)', async () => {
-    const { store } = makeStore(URL_AWARE)
-    installLocaleCorrector(store, URL_AWARE)
-
-    const stalePayload: Session = {
-      ...STALE,
-      person: {
-        id: 'p1',
-        email: 'a@b.com',
-        givenName: 'A',
-        familyName: 'B',
-      },
-    }
-    store.set(stalePayload)
-    await flushMicrotasks()
-
-    const corrected = store.read()
-    expect(corrected.locale).toBe('pt-BR')
-    expect(corrected.person).toEqual({
-      id: 'p1',
-      email: 'a@b.com',
-      givenName: 'A',
-      familyName: 'B',
-    })
-  })
-
-  it('replaces salesChannel inside channel JSON while preserving non-locale channel fields from the hydrated payload', async () => {
-    const { store } = makeStore(URL_AWARE)
-    installLocaleCorrector(store, URL_AWARE)
-
-    const stalePayload: Session = {
-      ...STALE,
-      channel:
-        '{"salesChannel":"2","regionId":"region-xyz","customKey":"keep-me"}',
-    }
-    store.set(stalePayload)
-    await flushMicrotasks()
-
-    const channel = JSON.parse(store.read().channel ?? '{}')
-    expect(channel.salesChannel).toBe('1')
-    expect(channel.regionId).toBe('region-xyz')
-    expect(channel.customKey).toBe('keep-me')
-  })
-
-  it('does not trigger an extra correction when IDB hydrates with a matching locale', async () => {
-    const { store, onValidate } = makeStore(URL_AWARE)
-    installLocaleCorrector(store, URL_AWARE)
-
-    // Simulates IDB hydration with the SAME locale as the URL-aware default.
-    store.set(URL_AWARE)
-    await flushMicrotasks()
-
-    expect(onValidate).toHaveBeenCalledTimes(1)
-    expect(onValidate.mock.calls[0][0].locale).toBe('pt-BR')
-    expect(store.read().locale).toBe('pt-BR')
-  })
-
-  it('only fires once: subsequent user-driven locale changes are NOT intercepted', async () => {
-    const { store, onValidate } = makeStore(URL_AWARE)
-    installLocaleCorrector(store, URL_AWARE)
-
-    // First hydration triggers the corrector.
-    store.set(STALE)
-    await flushMicrotasks()
-    expect(store.read().locale).toBe('pt-BR')
-    onValidate.mockClear()
-
-    // Now simulate a user changing locale via LocalizationSelector.
-    store.set(STALE)
-    await flushMicrotasks()
-
-    // The corrector must NOT undo this user-driven change.
-    expect(store.read().locale).toBe('en-US')
-    expect(onValidate).toHaveBeenCalledTimes(1)
-    expect(onValidate.mock.calls[0][0].locale).toBe('en-US')
-  })
-
-  it('returns an unsubscribe function that prevents future corrections', async () => {
-    const { store, onValidate } = makeStore(URL_AWARE)
-    const unsubscribe = installLocaleCorrector(store, URL_AWARE)
-    unsubscribe()
-
-    store.set(STALE)
-    await flushMicrotasks()
-
-    // Without the corrector active, the stale value stays in the store.
-    expect(store.read().locale).toBe('en-US')
-    expect(onValidate).toHaveBeenCalledTimes(1)
-    expect(onValidate.mock.calls[0][0].locale).toBe('en-US')
-  })
-
-  it('survives a malformed channel JSON in the hydrated payload (does not throw, still corrects)', async () => {
-    const { store, onValidate } = makeStore(URL_AWARE)
-    installLocaleCorrector(store, URL_AWARE)
-
-    const malformedPayload: Session = {
-      ...STALE,
-      // Simulates a corrupted IDB write — invalid JSON.
-      channel: '{not valid json',
-    }
-
-    // If the corrector threw, the surrounding `store.set` would abort the
-    // subscribers iteration and the optimistic handler queued for the stale
-    // payload would NOT be cancelled — re-introducing the race condition.
-    expect(() => store.set(malformedPayload)).not.toThrow()
-    await flushMicrotasks()
-
-    // Correction still applied: locale aligned with URL, salesChannel taken
-    // from the URL-aware initial session (since the malformed channel is
-    // treated as `{}`).
-    expect(store.read().locale).toBe('pt-BR')
-    const channel = JSON.parse(store.read().channel ?? '{}')
-    expect(channel.salesChannel).toBe('1')
-
-    // And the stale validation was cancelled — only the corrected one ran.
-    expect(onValidate).toHaveBeenCalledTimes(1)
-    expect(onValidate.mock.calls[0][0].locale).toBe('pt-BR')
-  })
-})