@faststore/core 4.9.1-dev.0 → 4.9.2

package/src/components/region/RegionModal/useRegion.ts

@@ -3,7 +3,7 @@ import { useState } from 'react'
 import type { Session } from '@faststore/sdk'
 import { deliveryPromise } from 'discovery.config'
 import { getProductCount } from 'src/sdk/product'
-import { sessionStore, validateSession } from 'src/sdk/session'
+import { sessionStore, toSessionInput, validateSession } from 'src/sdk/session'
 
 type SetRegionProps = {
   session: Session
@@ -40,8 +40,9 @@ export default function useRegion(): UseRegionValues {
     setLoading(true)
 
     try {
+      // `session` usually comes from `useSession()`, which also carries UI state
       const newSession = {
-        ...session,
+        ...toSessionInput(session),
         postalCode,
         geoCoordinates: null, // Revalidate geo coordinates in API when users set a new postal code
       } as Session

package/src/components/region/RegionPopover/RegionPopover.tsx

@@ -78,7 +78,7 @@ function RegionPopover(regionPopoverProps: RegionPopoverProps) {
   } = cmsData?.regionalization ?? {}
 
   const inputRef = useRef<HTMLInputElement>(null)
-  const { isValidating, isSessionReady, ...session } = useSession()
+  const { isValidating, ...session } = useSession()
   const { popover: displayPopover, closePopover } = useUI()
   const { onPostalCodeChange } = useDeliveryPromise()
   const { city, postalCode } = sessionStore.read()

package/src/components/region/RegionSlider/RegionSlider.tsx

@@ -45,7 +45,7 @@ function RegionSlider() {
     regionSlider: { type: regionSliderType, isOpen },
     closeRegionSlider,
   } = useUI()
-  const { isValidating, isSessionReady, ...session } = useSession()
+  const { isValidating, ...session } = useSession()
   const { state: searchState, setState: setSearchState } = useSearch()
   const {
     loading: loadingRegion,

package/src/pages/[slug]/p.tsx

@@ -30,7 +30,10 @@ import { execute } from 'src/server'
 import { getComponentKey } from 'src/utils/cms'
 import { getChannelForLocale } from 'src/utils/localization/bindingPaths'
 import { buildHreflangLinks } from 'src/utils/localization/hreflang'
-import { toProductJsonLdOffer } from 'src/utils/productJsonLd'
+import {
+  toProductJsonLdIdentifiers,
+  toProductJsonLdOffer,
+} from 'src/utils/productJsonLd'
 
 import storeConfig from 'discovery.config'
 import {
@@ -295,11 +298,9 @@ function Page({
         description={description}
         brand={product.brand.name}
         sku={product.sku}
-        // Spread conditionally so an unregistered identifier is omitted rather
-        // than published as "": next-seo passes these through untouched.
-        {...(product.gtin && { gtin: product.gtin })}
-        {...(product.mpn && { mpn: product.mpn })}
-        {...(product.releaseDate && { releaseDate: product.releaseDate })}
+        // Omits empty identifiers and normalizes releaseDate to ISO 8601; see
+        // toProductJsonLdIdentifiers.
+        {...toProductJsonLdIdentifiers(product)}
         images={product.image.map((img) => img.url)} // Somehow, Google does not understand this valid Schema.org schema, so we need to do conversions
         {...(offers && { offers })}
         {...(itemListElements.length !== 0 && {

package/src/sdk/account/useReorder.ts

@@ -10,7 +10,7 @@ import type {
 } from '@generated/graphql'
 import ReorderError from '../error/ReorderError/ReorderError'
 import { request } from '../graphql/request'
-import { sessionStore } from '../session'
+import { sessionStore, toSessionInput } from '../session'
 import { useLink } from '../ui/useLink'
 
 import storeConfig from '../../../discovery.config'
@@ -116,7 +116,7 @@ export const useReorder = () => {
         ValidateCartMutationMutation,
         ValidateCartMutationMutationVariables
       >(ValidateCartMutation, {
-        session: sessionStore.read(),
+        session: toSessionInput(sessionStore.read()),
         cart: {
           order: orderPayload as IStoreCart['order'],
         },

package/src/sdk/cart/index.ts

@@ -13,7 +13,11 @@ import type {
 
 import storeConfig from '../../../discovery.config'
 import { request } from '../graphql/request'
-import { hasValidatedSessionStore, sessionStore } from '../session'
+import {
+  hasValidatedSessionStore,
+  sessionStore,
+  toSessionInput,
+} from '../session'
 import { syncSalesChannelFromOrderForm } from '../session/syncSalesChannelFromOrderForm'
 import { createValidationStore, useStore } from '../useStore'
 import { waitForSessionValidated } from './waitForSessionValidated'
@@ -123,7 +127,9 @@ const validateCart = async (cart: Cart): Promise<Cart | null> => {
     ValidateCartMutationMutation,
     ValidateCartMutationMutationVariables
   >(ValidateCartMutation, {
-    session: sessionStore.read(),
+    // The session loaded from IndexedDB skips `sessionStore.set`, so it may
+    // still carry UI state persisted by an older version
+    session: toSessionInput(sessionStore.read()),
     cart: {
       order: {
         orderNumber: cart.id,

package/src/sdk/session/index.ts

@@ -21,6 +21,9 @@ import { createValidationStore, useStore } from '../useStore'
 import { getPostalCode } from '../userLocation/index'
 import { getInitialSession, reconcileSessionLocale } from './initialSession'
 import { RELOAD_AFTER_LOGOUT_KEY, SESSION_READY_KEY } from './storageKeys'
+import { type SessionUIKey, toSessionInput } from './toSessionInput'
+
+export { toSessionInput } from './toSessionInput'
 
 const isReloadAfterLogoutPending = (): boolean => {
   try {
@@ -160,18 +163,11 @@ export const validateSession = async (session: Session) => {
       return null
     }
 
-    // Remove fields that are not part of IStoreSession type
-    const { isSessionReady, isValidating, ...sessionWithoutExtras } =
-      session as Session & {
-        isSessionReady?: boolean
-        isValidating?: boolean
-      }
-
     const data = await request<
       ValidateSessionMutation,
       ValidateSessionMutationVariables
     >(mutation, {
-      session: sessionWithoutExtras,
+      session: toSessionInput(session),
       search: window.location.search,
     })
 
@@ -210,9 +206,11 @@ const defaultStore = createSessionStore(
 export const sessionStore = {
   ...defaultStore,
   set: (val: Session) => {
-    if (deepEqual(val, defaultStore.read()) === true) return
+    // Also drops UI state already persisted, since `session` then differs
+    const session = toSessionInput(val)
+    if (deepEqual(session, defaultStore.read()) === true) return
 
-    defaultStore.set(val)
+    defaultStore.set(session)
 
     // Trigger cart revalidation when session changes
     cartStore.set(cartStore.read())
@@ -224,9 +222,10 @@ export const sessionStore = {
    * path keeps an explicit (non-default) client SC.
    */
   setSilent: (val: Session) => {
-    if (deepEqual(val, defaultStore.read()) === true) return
+    const session = toSessionInput(val)
+    if (deepEqual(session, defaultStore.read()) === true) return
 
-    defaultStore.set(val)
+    defaultStore.set(session)
   },
 }
 
@@ -276,16 +275,17 @@ export const useSession = ({ filter }: SessionOptions = { filter: true }) => {
     channel = filterChannel(channel ?? '')
   }
 
-  return useMemo(
-    () => ({
-      ...session,
-      channel,
+  return useMemo(() => {
+    // Must match `SESSION_UI_KEYS`, which `toSessionInput` strips before the
+    // session is stored or sent to the API
+    const uiState = {
       isValidating,
       isSessionReady,
       hasValidated,
-    }),
-    [isValidating, session, channel, isSessionReady, hasValidated]
-  )
+    } satisfies Record<SessionUIKey, boolean>
+
+    return { ...session, channel, ...uiState }
+  }, [isValidating, session, channel, isSessionReady, hasValidated])
 }
 
 /**

package/src/sdk/session/toSessionInput.ts

@@ -0,0 +1,27 @@
+import type { Session } from '@faststore/sdk'
+
+/** UI-only state that `useSession()` returns next to the session fields. */
+export const SESSION_UI_KEYS = [
+  'isSessionReady',
+  'isValidating',
+  'hasValidated',
+] as const
+
+export type SessionUIKey = (typeof SESSION_UI_KEYS)[number]
+
+type SessionUIState = Partial<Record<SessionUIKey, boolean>>
+
+/**
+ * Returns the session without the UI-only state, as `IStoreSession` expects.
+ * GraphQL rejects unknown input fields, so a session that carries them (e.g.
+ * built from `useSession()` or persisted that way) fails every validation.
+ */
+export function toSessionInput(session: Session & SessionUIState): Session {
+  const input = { ...session }
+
+  for (const key of SESSION_UI_KEYS) {
+    delete input[key]
+  }
+
+  return input
+}

package/src/utils/productJsonLd.ts

@@ -1,6 +1,7 @@
 import type { ServerProductQueryQuery } from '@generated/graphql'
 
-type ServerOffers = ServerProductQueryQuery['product']['offers']
+type ServerProduct = ServerProductQueryQuery['product']
+type ServerOffers = ServerProduct['offers']
 type ServerOffer = ServerOffers['offers'][number]
 
 /**
@@ -69,3 +70,101 @@ export const toProductJsonLdOffer = (
 
   return offer
 }
+
+// Epoch values are disambiguated by magnitude, not digit count: anything at or
+// above this is milliseconds (>= 1973-03-03), anything below is seconds. A
+// millisecond value under the threshold is read as seconds — accepted, since no
+// real catalog carries a release date that early, and a digit-count heuristic
+// leaves a strictly larger hole (9-digit seconds and 12-digit milliseconds both
+// fall through to the string parser, which reads them as a year).
+const MILLISECONDS_THRESHOLD = 1e11
+
+const isAllDigits = (value: string) => /^\d+$/.test(value)
+
+// An ISO date-time with no timezone designator. `new Date()` reads these as
+// host-local time (date-only forms are already read as UTC), which would make
+// the emitted calendar day depend on the build machine's zone.
+const ISO_DATE_TIME_WITHOUT_ZONE =
+  /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(:\d{2}(\.\d+)?)?$/
+
+const toDate = (value: string): Date => {
+  if (!isAllDigits(value)) {
+    return new Date(
+      ISO_DATE_TIME_WITHOUT_ZONE.test(value) ? `${value}Z` : value
+    )
+  }
+
+  const epoch = Number(value)
+
+  return new Date(epoch >= MILLISECONDS_THRESHOLD ? epoch : epoch * 1000)
+}
+
+/**
+ * Normalizes `StoreProduct.releaseDate` to the ISO 8601 calendar date
+ * (`YYYY-MM-DD`) Schema.org expects for the PDP's `ProductJsonLd`.
+ *
+ * The API passes the field through as Intelligent Search delivers it — epoch
+ * milliseconds for most accounts, an ISO string for others — because stores
+ * read that raw value in their own customizations. Normalizing here, and only
+ * here, keeps the structured data valid without changing that contract.
+ *
+ * Accepts epoch milliseconds, epoch seconds, and date strings. Returns an empty
+ * string when the input is absent or unparseable — never throws, and never
+ * returns `"Invalid Date"`.
+ *
+ * The calendar day is always taken in UTC, so a build produces the same markup
+ * on any machine. An input carrying a timezone offset is converted first, which
+ * means `2026-03-23T21:00:00-05:00` normalizes to `2026-03-24`. That is
+ * deliberate: preserving the source calendar day would make the output depend on
+ * the offset embedded in each record. An input with no timezone designator is
+ * read as UTC rather than as host-local time, for the same reason.
+ */
+export const toProductJsonLdReleaseDate = (
+  value: string | number | null | undefined
+): string => {
+  if (value === null || value === undefined) {
+    return ''
+  }
+
+  const raw = String(value).trim()
+
+  if (raw === '') {
+    return ''
+  }
+
+  const date = toDate(raw)
+
+  if (Number.isNaN(date.getTime())) {
+    return ''
+  }
+
+  return date.toISOString().slice(0, 10)
+}
+
+/**
+ * Builds the identifier props (`gtin`, `mpn`, `releaseDate`) for the PDP's
+ * `ProductJsonLd`, ready to spread.
+ *
+ * Every key is omitted when its value is empty, because next-seo publishes
+ * props untouched and an empty string is invalid Schema.org. `releaseDate` is
+ * normalized here because `StoreProduct.releaseDate` is the raw upstream value
+ * (usually epoch milliseconds), which Schema.org consumers reject.
+ *
+ * This lives here rather than inline in `p.tsx` so the rendering tests exercise
+ * the same code the page runs: passing `product.releaseDate` straight through
+ * would publish `"1774224000000"` and still leave a unit test of the
+ * normalizer green.
+ */
+export const toProductJsonLdIdentifiers = ({
+  gtin,
+  mpn,
+  releaseDate,
+}: Pick<ServerProduct, 'gtin' | 'mpn' | 'releaseDate'>) => {
+  const normalizedReleaseDate = toProductJsonLdReleaseDate(releaseDate)
+
+  return {
+    ...(gtin && { gtin }),
+    ...(mpn && { mpn }),
+    ...(normalizedReleaseDate && { releaseDate: normalizedReleaseDate }),
+  }
+}

package/test/components/region/useRegion.browser.test.ts

@@ -0,0 +1,64 @@
+import type { Session } from '@faststore/sdk'
+import { act, renderHook } from '@testing-library/react'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+const mockValidateSession = vi.hoisted(() => vi.fn())
+const mockSessionSet = vi.hoisted(() => vi.fn())
+
+vi.mock('src/sdk/session', async () => ({
+  validateSession: mockValidateSession,
+  sessionStore: { set: mockSessionSet },
+  toSessionInput: (await import('src/sdk/session/toSessionInput'))
+    .toSessionInput,
+}))
+
+vi.mock('src/sdk/product', () => ({
+  getProductCount: vi.fn().mockResolvedValue(1),
+}))
+
+import useRegion from '../../../src/components/region/RegionModal/useRegion'
+
+const session: Session = {
+  locale: 'en-US',
+  currency: { code: 'USD', symbol: '$' },
+  country: 'USA',
+  channel: '{"salesChannel":"1","regionId":""}',
+  deliveryMode: null,
+  addressType: null,
+  city: null,
+  postalCode: null,
+  geoCoordinates: null,
+  person: null,
+  b2b: null,
+  marketingData: null,
+  refreshAfter: null,
+}
+
+describe('useRegion', () => {
+  afterEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('keeps the UI state from useSession() out of the new session', async () => {
+    mockValidateSession.mockResolvedValue(null)
+    const { result } = renderHook(() => useRegion())
+
+    await act(() =>
+      result.current.setRegion({
+        session: {
+          ...session,
+          isValidating: false,
+          isSessionReady: true,
+          hasValidated: true,
+        } as Session,
+        postalCode: '10001',
+        errorMessage: 'error',
+      })
+    )
+
+    const expected = { ...session, postalCode: '10001' }
+
+    expect(mockValidateSession).toHaveBeenCalledWith(expected)
+    expect(mockSessionSet).toHaveBeenCalledWith(expected)
+  })
+})

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

@@ -0,0 +1,63 @@
+import type { Session } from '@faststore/sdk'
+import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
+
+const mockRequest = vi.hoisted(() => vi.fn())
+
+vi.mock('../../../src/sdk/graphql/request', () => ({
+  request: mockRequest,
+}))
+
+import { sessionStore } from '../../../src/sdk/session'
+
+const session: Session = {
+  locale: 'en-US',
+  currency: { code: 'USD', symbol: '$' },
+  country: 'USA',
+  channel: '{"salesChannel":"1","regionId":""}',
+  deliveryMode: null,
+  addressType: null,
+  city: null,
+  postalCode: '10001',
+  geoCoordinates: null,
+  person: null,
+  b2b: null,
+  marketingData: null,
+  refreshAfter: null,
+}
+
+const withUIState = {
+  isValidating: false,
+  isSessionReady: true,
+  hasValidated: true,
+}
+
+describe('sessionStore', () => {
+  beforeAll(async () => {
+    mockRequest.mockResolvedValue({ validateSession: null })
+    // The store validates its initial session on load; let it settle first
+    await vi.waitFor(() => expect(mockRequest).toHaveBeenCalled())
+  })
+
+  beforeEach(() => {
+    mockRequest.mockClear()
+  })
+
+  it('does not store the UI state from useSession()', () => {
+    sessionStore.set({ ...session, ...withUIState } as Session)
+
+    expect(sessionStore.read()).toStrictEqual(session)
+  })
+
+  it('does not store the UI state on a silent update', () => {
+    sessionStore.setSilent({
+      ...session,
+      postalCode: '10002',
+      ...withUIState,
+    } as Session)
+
+    expect(sessionStore.read()).toStrictEqual({
+      ...session,
+      postalCode: '10002',
+    })
+  })
+})

package/test/sdk/session/toSessionInput.test.ts

@@ -0,0 +1,43 @@
+import type { Session } from '@faststore/sdk'
+import { describe, expect, it } from 'vitest'
+
+import { toSessionInput } from '../../../src/sdk/session/toSessionInput'
+
+const session: Session = {
+  locale: 'en-US',
+  currency: { code: 'USD', symbol: '$' },
+  country: 'USA',
+  channel: '{"salesChannel":"1","regionId":""}',
+  deliveryMode: null,
+  addressType: null,
+  city: null,
+  postalCode: '10001',
+  geoCoordinates: null,
+  person: null,
+  b2b: null,
+  marketingData: null,
+  refreshAfter: null,
+}
+
+describe('toSessionInput', () => {
+  it('drops the UI state useSession() adds, which IStoreSession rejects', () => {
+    expect(
+      toSessionInput({
+        ...session,
+        isValidating: false,
+        isSessionReady: true,
+        hasValidated: true,
+      })
+    ).toEqual(session)
+  })
+
+  it('strips the UI state from a session persisted with it', () => {
+    const persisted = { ...session, hasValidated: true } as Session
+
+    expect(toSessionInput(persisted)).toEqual(session)
+  })
+
+  it('keeps a clean session as is', () => {
+    expect(toSessionInput(session)).toEqual(session)
+  })
+})

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

@@ -0,0 +1,47 @@
+import type { Session } from '@faststore/sdk'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const mockRequest = vi.hoisted(() => vi.fn())
+
+vi.mock('../../../src/sdk/graphql/request', () => ({
+  request: mockRequest,
+}))
+
+import { validateSession } from '../../../src/sdk/session'
+
+const session: Session = {
+  locale: 'en-US',
+  currency: { code: 'USD', symbol: '$' },
+  country: 'USA',
+  channel: '{"salesChannel":"1","regionId":""}',
+  deliveryMode: null,
+  addressType: null,
+  city: null,
+  postalCode: '10001',
+  geoCoordinates: null,
+  person: null,
+  b2b: null,
+  marketingData: null,
+  refreshAfter: null,
+}
+
+describe('validateSession', () => {
+  beforeEach(async () => {
+    mockRequest.mockResolvedValue({ validateSession: null })
+    // The store validates its initial session on load; let it settle first
+    await vi.waitFor(() => expect(mockRequest).toHaveBeenCalled())
+    mockRequest.mockClear()
+  })
+
+  it('does not send the UI state persisted with the session', async () => {
+    await validateSession({
+      ...session,
+      isValidating: false,
+      isSessionReady: true,
+      hasValidated: true,
+    } as Session)
+
+    expect(mockRequest).toHaveBeenCalledTimes(1)
+    expect(mockRequest.mock.calls[0][1].session).toStrictEqual(session)
+  })
+})

package/test/utils/productJsonLd.test.ts

@@ -1,5 +1,9 @@
 import { describe, expect, it } from 'vitest'
-import { toProductJsonLdOffer } from '../../src/utils/productJsonLd'
+import {
+  toProductJsonLdIdentifiers,
+  toProductJsonLdOffer,
+  toProductJsonLdReleaseDate,
+} from '../../src/utils/productJsonLd'
 
 const OBJECT_LEVEL = { priceCurrency: 'USD', url: 'https://store.example/p' }
 
@@ -124,3 +128,99 @@ describe('toProductJsonLdOffer', () => {
     ).toBeUndefined()
   })
 })
+
+describe('toProductJsonLdReleaseDate', () => {
+  const resolve = toProductJsonLdReleaseDate
+
+  it('converts epoch milliseconds to an ISO calendar date', () => {
+    expect(resolve('1774224000000')).toBe('2026-03-23')
+  })
+
+  it('converts epoch seconds to the same date as its millisecond form', () => {
+    expect(resolve('1774224000')).toBe(resolve('1774224000000'))
+  })
+
+  it('reads a value at the millisecond threshold as milliseconds', () => {
+    expect(resolve('100000000000')).toBe('1973-03-03')
+  })
+
+  it('reads a value just below the threshold as seconds', () => {
+    expect(resolve('99999999999')).toBe('5138-11-16')
+  })
+
+  it('accepts a numeric epoch, not only its string form', () => {
+    expect(resolve(1774224000000)).toBe('2026-03-23')
+  })
+
+  it('passes an ISO date through unchanged', () => {
+    expect(resolve('2026-03-23')).toBe('2026-03-23')
+  })
+
+  it('truncates an ISO datetime to its calendar date', () => {
+    expect(resolve('2026-03-23T14:30:00Z')).toBe('2026-03-23')
+  })
+
+  // UTC is deliberate: preserving the source calendar day would make the
+  // output depend on the offset embedded in each record.
+  it('resolves an offset that crosses midnight to the UTC day', () => {
+    expect(resolve('2026-03-23T21:00:00-05:00')).toBe('2026-03-24')
+  })
+
+  // `new Date(...)` reads an ISO date-time with no timezone designator as
+  // host-local, so without explicit handling this value resolves to the day
+  // before in any zone ahead of UTC. The build machine must not change the
+  // markup.
+  it('reads an ISO date-time with no timezone as UTC, not host-local', () => {
+    expect(resolve('2026-03-23T00:30:00')).toBe('2026-03-23')
+  })
+
+  it('reads an end-of-day ISO date-time with no timezone as UTC', () => {
+    expect(resolve('2026-03-23T23:30:00')).toBe('2026-03-23')
+  })
+
+  it.each([
+    ['an empty string', ''],
+    ['whitespace', '   '],
+    ['an unparseable value', 'not-a-date'],
+    ['null', null],
+    ['undefined', undefined],
+  ])('returns an empty string for %s', (_label, input) => {
+    expect(resolve(input)).toBe('')
+  })
+
+  it('never returns "Invalid Date"', () => {
+    expect(resolve('garbage')).not.toContain('Invalid')
+  })
+})
+
+describe('toProductJsonLdIdentifiers', () => {
+  it('normalizes an epoch releaseDate to an ISO calendar date', () => {
+    expect(
+      toProductJsonLdIdentifiers({
+        gtin: '0012345678905',
+        mpn: 'MPN-1',
+        releaseDate: '1774224000000',
+      })
+    ).toEqual({
+      gtin: '0012345678905',
+      mpn: 'MPN-1',
+      releaseDate: '2026-03-23',
+    })
+  })
+
+  it('omits every identifier that is empty', () => {
+    expect(
+      toProductJsonLdIdentifiers({ gtin: '', mpn: '', releaseDate: '' })
+    ).toEqual({})
+  })
+
+  it('omits a releaseDate that cannot be parsed', () => {
+    expect(
+      toProductJsonLdIdentifiers({
+        gtin: '',
+        mpn: '',
+        releaseDate: 'not-a-date',
+      })
+    ).toEqual({})
+  })
+})