@faststore/core 4.5.0-dev.0 → 4.5.0-dev.2

package/src/sdk/account/changeContractToken.ts

@@ -0,0 +1,119 @@
+import fetch from 'isomorphic-unfetch'
+
+import storeConfig from '../../../discovery.config'
+
+export class ContractSwitchError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'ContractSwitchError'
+  }
+}
+
+export const isContractSwitchEnabled = true
+
+type VtexAuthCookie = {
+  Name: string
+  Value: string
+}
+
+export type SwitchPropertiesResponse = {
+  authStatus?: string
+  expiresIn?: number
+  authCookie?: VtexAuthCookie | null
+  accountAuthCookie?: VtexAuthCookie | null
+}
+
+const DEFAULT_AUTH_COOKIE_MAX_AGE = 86_400
+const SWITCH_PROPERTIES_TIMEOUT_MS = 30_000
+
+export function applyVtexAuthCookieFromSwitchResponse(
+  response: SwitchPropertiesResponse
+): void {
+  if (globalThis.window === undefined) {
+    return
+  }
+
+  const maxAge = response.expiresIn ?? DEFAULT_AUTH_COOKIE_MAX_AGE
+  const secure =
+    globalThis.window.location.protocol === 'https:' ? '; secure' : ''
+
+  const cookies = [response.authCookie, response.accountAuthCookie].filter(
+    (cookie): cookie is VtexAuthCookie =>
+      Boolean(cookie?.Name?.trim() && cookie?.Value)
+  )
+
+  for (const cookie of cookies) {
+    document.cookie = `${cookie.Name}=${cookie.Value}; path=/; max-age=${maxAge}; samesite=lax${secure}`
+  }
+}
+
+/**
+ * Switches the buyer's active contract via VTEX Identity storefront credential API.
+ *
+ * POST /api/authenticator/storefront/credential/switch-properties?an={account}
+ * Body: { properties: { customerId: contractId } }
+ *
+ * Applies the returned `authCookie` (and optional `accountAuthCookie`) so the
+ * storefront JWT reflects the new commercial context. Throws `ContractSwitchError`
+ * on hard failures so `switchContract` can keep the previous contract active.
+ */
+export async function changeContractToken(
+  contractId: string
+): Promise<boolean> {
+  if (!contractId) {
+    throw new ContractSwitchError('Missing contractId for contract switch')
+  }
+
+  const an = encodeURIComponent(storeConfig.api.storeId)
+  const url = `/api/authenticator/storefront/credential/switch-properties?an=${an}`
+
+  let response: Response
+  try {
+    response = await fetch(url, {
+      method: 'POST',
+      credentials: 'include',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        properties: {
+          customerId: contractId,
+        },
+      }),
+      signal: AbortSignal.timeout(SWITCH_PROPERTIES_TIMEOUT_MS),
+    })
+  } catch (error) {
+    if (
+      error instanceof Error &&
+      (error.name === 'TimeoutError' || error.name === 'AbortError')
+    ) {
+      throw new ContractSwitchError('Contract switch timed out')
+    }
+
+    throw error instanceof Error
+      ? new ContractSwitchError(`Failed to switch contract: ${error.message}`)
+      : new ContractSwitchError('Failed to switch contract')
+  }
+
+  if (!response.ok) {
+    throw new ContractSwitchError(
+      `Failed to switch contract (${response.status})`
+    )
+  }
+
+  const payload = (await response.json()) as SwitchPropertiesResponse
+
+  if (payload.authStatus?.toLowerCase() !== 'success') {
+    throw new ContractSwitchError('Contract switch was not successful')
+  }
+
+  if (!payload.authCookie?.Name || !payload.authCookie?.Value) {
+    throw new ContractSwitchError(
+      'Contract switch succeeded but no auth cookie was returned'
+    )
+  }
+
+  applyVtexAuthCookieFromSwitchResponse(payload)
+
+  return true
+}

package/src/sdk/account/clearPersistedSessionState.ts

@@ -0,0 +1,26 @@
+import { SESSION_READY_KEY } from '../session/storageKeys'
+import {
+  STORAGE_KEY_CACHE_BUST_LAST_VALUE,
+  STORAGE_KEY_PERSON_ID,
+} from 'src/utils/cookieCacheBusting'
+
+/**
+ * Clears client-side session persistence so a hard reload rehydrates from
+ * validateSession instead of stale IndexedDB / sessionStorage values.
+ */
+export async function clearPersistedSessionState(): Promise<void> {
+  try {
+    const { del } = await import('idb-keyval')
+    await del('fs::session').catch(() => {})
+  } catch {}
+
+  if (typeof sessionStorage === 'undefined') {
+    return
+  }
+
+  try {
+    sessionStorage.removeItem(SESSION_READY_KEY)
+    sessionStorage.removeItem(STORAGE_KEY_PERSON_ID)
+    sessionStorage.removeItem(STORAGE_KEY_CACHE_BUST_LAST_VALUE)
+  } catch {}
+}

package/src/sdk/account/refreshToken.ts

@@ -25,19 +25,32 @@ async function fetchWithRetry(
   return undefined
 }
 
-export const refreshTokenRequest = async (): Promise<
-  RefreshTokenResponse | undefined
-> => {
-  const storeOriginURL = new URL(getStoreURL()).origin
-  const REFRESH_TOKEN_URL = `${storeOriginURL}/api/vtexid/refreshtoken/webstore`
+function getRefreshTokenUrl(): string {
+  if (globalThis.window !== undefined) {
+    return '/api/vtexid/refreshtoken/webstore'
+  }
+
+  return `${new URL(getStoreURL()).origin}/api/vtexid/refreshtoken/webstore`
+}
+
+function getRefreshTokenHeaders(): HeadersInit {
   const headers: HeadersInit = {
     'content-type': 'application/json',
-    Host: `${sanitizeHost(storeOriginURL)}`,
   }
 
-  return await fetchWithRetry(REFRESH_TOKEN_URL, {
+  if (globalThis.window === undefined) {
+    headers.Host = `${sanitizeHost(new URL(getStoreURL()).origin)}`
+  }
+
+  return headers
+}
+
+export const refreshTokenRequest = async (): Promise<
+  RefreshTokenResponse | undefined
+> => {
+  return fetchWithRetry(getRefreshTokenUrl(), {
     credentials: 'include',
-    headers,
+    headers: getRefreshTokenHeaders(),
     body: JSON.stringify({}),
     method: 'POST',
   })

package/src/sdk/account/useAvailableContracts.ts

@@ -0,0 +1,49 @@
+import { gql } from '@generated'
+import type {
+  AvailableContractsQueryQuery,
+  AvailableContractsQueryQueryVariables,
+} from '@generated/graphql'
+
+import { useQuery } from '../graphql/useQuery'
+import { useSession } from '../session'
+
+export const AvailableContractsQuery = gql(`
+  query AvailableContractsQuery($orgUnitId: String!) {
+    availableContracts(orgUnitId: $orgUnitId) {
+      id
+      corporateName
+      isActive
+    }
+  }
+`)
+
+export type AvailableContract =
+  AvailableContractsQueryQuery['availableContracts'][number]
+
+/**
+ * Lists the contracts associated with the current buyer's Organization Unit,
+ * resolved to human-readable corporate names. The list is governed server-side:
+ * only contracts associated with the Org Unit are ever returned (REQ-05).
+ *
+ * The query is gated by `enabled` so it only runs on demand (e.g. when the
+ * switcher is opened), protecting performance budgets.
+ */
+export const useAvailableContracts = (enabled = true) => {
+  const { b2b } = useSession()
+  const orgUnitId = b2b?.unitId ?? ''
+
+  const { data, error, isValidating } = useQuery<
+    AvailableContractsQueryQuery,
+    AvailableContractsQueryQueryVariables
+  >(
+    AvailableContractsQuery,
+    { orgUnitId },
+    { doNotRun: !enabled || !orgUnitId, dedupingInterval: 0 }
+  )
+
+  return {
+    contracts: data?.availableContracts ?? [],
+    loading: (enabled && !!orgUnitId && !data && !error) || isValidating,
+    error: error ?? null,
+  }
+}

package/src/sdk/account/useSwitchContract.ts

@@ -0,0 +1,60 @@
+import { useState } from 'react'
+
+import { clearPersistedSessionState } from './clearPersistedSessionState'
+import {
+  ContractSwitchError,
+  changeContractToken,
+  isContractSwitchEnabled,
+} from './changeContractToken'
+
+/**
+ * Orchestrates a full change of commercial context (REQ-06).
+ *
+ * Steps:
+ *  1. POST switch-properties with the target contract id and apply the returned auth cookie.
+ *  2. Clear persisted session state and reload the page.
+ */
+export const useSwitchContract = () => {
+  const [loading, setLoading] = useState(false)
+  const [error, setError] = useState<Error | null>(null)
+
+  const switchContract = async (contractId: string): Promise<boolean> => {
+    setLoading(true)
+    setError(null)
+
+    try {
+      const switched = await changeContractToken(contractId)
+      if (!switched) {
+        setError(
+          new ContractSwitchError('Contract switching is not available yet')
+        )
+        return false
+      }
+
+      await clearPersistedSessionState()
+
+      if (globalThis.window !== undefined) {
+        globalThis.window.location.reload()
+      }
+
+      return true
+    } catch (err) {
+      const normalized =
+        err instanceof Error
+          ? err
+          : new ContractSwitchError('Failed to switch contract')
+      setError(normalized)
+
+      return false
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  return {
+    switchContract,
+    loading,
+    error,
+    enabled: isContractSwitchEnabled,
+  }
+}

package/src/sdk/analytics/hooks/useStartRecommendationSession.ts

@@ -0,0 +1,96 @@
+import { useEffect } from 'react'
+
+import { gql } from '@faststore/core/api'
+
+import storeConfig from 'discovery.config'
+import { useLazyQuery } from 'src/sdk/graphql/useLazyQuery'
+import { getCookie } from 'src/utils/getCookie'
+import { retry } from 'src/utils/retry'
+
+// Cookie set once the anonymous personalization session has been started,
+// so we only fire `StartRecommendationSession` a single time per browser session.
+const VTEX_REC_USER_START_SESSION = 'vtex-rec-user-start-session'
+
+const startRecommendationSessionMutation = gql(`
+  mutation StartRecommendationSession {
+    startRecommendationSession
+  }
+`)
+
+type StartRecommendationSessionData = { startRecommendationSession: boolean }
+type StartRecommendationSessionVariables = Record<string, never>
+
+/**
+ * Starts the anonymous recommendation/personalization session once per browser
+ * session.
+ *
+ * Mounted globally from `Layout` so it runs on every page, regardless of
+ * whether a recommendation section is present.
+ *
+ * The product view is no longer reported through a mutation here: the PDP now
+ * exposes the product data as `<meta property="product:*">` tags, which the
+ * Activity Flow script reads to capture the product view event.
+ *
+ * All work runs client-side in effects (after hydration), so it doesn't affect
+ * SSR/TTFB or Lighthouse render metrics.
+ *
+ * Gated behind the `experimental.enableRecommendations` flag: stores that don't
+ * opt into Recommendations never start a session nor hit the Recommendations API.
+ */
+export function useStartRecommendationSession() {
+  const [runStartRecommendationSession] = useLazyQuery<
+    StartRecommendationSessionData,
+    StartRecommendationSessionVariables
+  >(
+    startRecommendationSessionMutation,
+    {} as StartRecommendationSessionVariables,
+    {
+      doNotRun: true,
+    }
+  )
+
+  useEffect(() => {
+    if (!storeConfig.experimental.enableRecommendations) {
+      return
+    }
+
+    const startRecommendationSessionCookie = getCookie(
+      VTEX_REC_USER_START_SESSION
+    )
+
+    if (startRecommendationSessionCookie) {
+      return
+    }
+
+    const controller = new AbortController()
+
+    // The session endpoint may not be ready on the first try, so we retry with
+    // exponential backoff until it returns a defined result (or we give up).
+    // Transient request/GraphQL rejections are treated as retryable: swallow
+    // the error and return `undefined` so the backoff loop keeps going instead
+    // of aborting on the first failure.
+    void retry(
+      async () => {
+        try {
+          return await runStartRecommendationSession({})
+        } catch {
+          return undefined
+        }
+      },
+      {
+        attempts: 10,
+        delayMs: 300,
+        backoff: true,
+        maxDelayMs: 3000,
+        until: (result) => result !== undefined,
+        signal: controller.signal,
+      }
+      // Guard the discarded promise so a give-up (or any unexpected rejection)
+      // never surfaces as an unhandled promise rejection.
+    ).catch(() => {})
+
+    return () => {
+      controller.abort()
+    }
+  }, [runStartRecommendationSession])
+}

package/src/sdk/analytics/utils.ts

@@ -0,0 +1,9 @@
+import { getCookie } from 'src/utils/getCookie'
+
+// Name of the cookie that holds the anonymous user id used by the
+// recommendation/personalization pixel.
+const USER_ID_COOKIE = 'vtex-rec-user-id'
+
+export function getUserIdFromCookie(): string {
+  return getCookie(USER_ID_COOKIE) ?? ''
+}

package/src/utils/retry.ts

@@ -0,0 +1,69 @@
+export interface RetryOptions<T> {
+  /**
+   * Maximum number of retries after the initial attempt.
+   * @default 5
+   */
+  attempts?: number
+  /**
+   * Delay between attempts, in milliseconds.
+   * @default 500
+   */
+  delayMs?: number
+  /**
+   * Doubles the delay after each attempt, capped at `maxDelayMs`.
+   * @default false
+   */
+  backoff?: boolean
+  /**
+   * Upper bound for the delay when `backoff` is enabled.
+   * @default 3000
+   */
+  maxDelayMs?: number
+  /**
+   * Stops retrying once this predicate returns `true`. Defaults to "the value
+   * is truthy".
+   */
+  until?: (value: T) => boolean
+  /**
+   * Aborts the retry loop early (e.g. on component unmount).
+   */
+  signal?: AbortSignal
+}
+
+// Repeatedly calls `fn` until `until` is satisfied or the retry budget is
+// exhausted. Useful when a value is produced asynchronously by an external
+// script (e.g. a cookie set by a pixel, or an endpoint that is not ready on
+// the first call). Returns the last value produced, even when the budget runs
+// out, so callers can decide how to handle the give-up case.
+export async function retry<T>(
+  fn: () => T | Promise<T>,
+  {
+    attempts = 5,
+    delayMs = 500,
+    backoff = false,
+    maxDelayMs = 3000,
+    until = Boolean,
+    signal,
+  }: RetryOptions<T> = {}
+): Promise<T> {
+  let value = await fn()
+  let delay = delayMs
+  let remaining = attempts
+
+  while (!until(value) && remaining > 0 && !signal?.aborted) {
+    await new Promise((resolve) => setTimeout(resolve, delay))
+
+    if (signal?.aborted) {
+      break
+    }
+
+    value = await fn()
+    remaining -= 1
+
+    if (backoff) {
+      delay = Math.min(delay * 2, maxDelayMs)
+    }
+  }
+
+  return value
+}