@faststore/core 4.10.1 → 4.10.2

package/src/sdk/session/index.ts

@@ -8,10 +8,12 @@ import type {
   ValidateSessionMutationVariables,
 } from '@generated/graphql'
 import deepEqual from 'fast-deep-equal'
-import { isLocalHostBrowser } from 'src/utils/isLocalHost'
+import { shouldBypassRefreshTokenBrowser } from 'src/utils/shouldBypassRefreshToken'
 import { filterChannel } from 'src/utils/utilities'
 import storeConfig from '../../../discovery.config'
 import {
+  getNextRefreshAfter,
+  isB2BSession,
   isRefreshTokenSuccessful,
   refreshTokenRequest,
 } from '../account/refreshToken'
@@ -94,14 +96,12 @@ export const mutation = gql(`
 `)
 
 async function handleRefreshToken(session: Session): Promise<Session | null> {
-  const result = await refreshTokenRequest()
+  const result = await refreshTokenRequest({ isB2B: isB2BSession(session) })
 
   if (isRefreshTokenSuccessful(result)) {
     return {
       ...session,
-      refreshAfter: String(
-        Math.floor(new Date(result?.refreshAfter).getTime() / 1000)
-      ),
+      refreshAfter: getNextRefreshAfter(result),
     }
   }
 
@@ -109,6 +109,43 @@ async function handleRefreshToken(session: Session): Promise<Session | null> {
   return null
 }
 
+/**
+ * The refresh-token flow runs only when `experimental.refreshToken` is on and
+ * the host can reach VTEX ID: localhost and WebOps previews do not proxy it.
+ */
+function canRefreshToken(): boolean {
+  return (
+    !!storeConfig.experimental?.refreshToken &&
+    !shouldBypassRefreshTokenBrowser()
+  )
+}
+
+/**
+ * With deliveryPromise on and no postalCode in the session, fills it from the
+ * B2B saved address or from the shopper location.
+ */
+async function syncDeliveryPromisePostalCode(session: Session) {
+  if (
+    !storeConfig.deliveryPromise?.enabled ||
+    (session.postalCode &&
+      session.postalCode !== storeConfig.session.postalCode)
+  ) {
+    return
+  }
+
+  // Case B2B: If a B2B shopper is logged in and a saved address is available, the postalCode field is automatically updated with the postal code from that address by the B2B session apps (shopper-session and profile-session).
+  if (session.b2b?.savedPostalCode) {
+    sessionStore.set({
+      ...session,
+      postalCode: session.b2b.savedPostalCode,
+    })
+    return
+  }
+
+  const sessionWithLocation = await getPostalCode(session)
+  !!sessionWithLocation && sessionStore.set(sessionWithLocation)
+}
+
 function isRefreshAfterExpired(session: Session): boolean {
   return (
     !!session.refreshAfter &&
@@ -126,12 +163,8 @@ export const validateSession = async (session: Session) => {
   // If the refreshToken is enabled and the refreshAfter is expired, refresh the token.
   // On success, continue to the validation flow with the refreshed session.
   // On failure (logoutAndClearSession already triggered), bail out.
-  // Skipped in local environments where the refresh token infrastructure is unavailable.
-  if (
-    !isLocalHostBrowser() &&
-    storeConfig.experimental?.refreshToken &&
-    isRefreshAfterExpired(session)
-  ) {
+  // Skipped on localhost and WebOps previews, where the refresh token infrastructure is unavailable.
+  if (canRefreshToken() && isRefreshAfterExpired(session)) {
     const refreshed = await handleRefreshToken(session)
     if (!refreshed) {
       return null
@@ -139,23 +172,7 @@ export const validateSession = async (session: Session) => {
     session = refreshed
   }
 
-  // If deliveryPromise is enabled and there is no postalCode in the session
-  if (
-    storeConfig.deliveryPromise?.enabled &&
-    (!session.postalCode ||
-      session.postalCode === storeConfig.session.postalCode)
-  ) {
-    // Case B2B: If a B2B shopper is logged in and a saved address is available, the postalCode field is automatically updated with the postal code from that address by the B2B session apps (shopper-session and profile-session).
-    if (session.b2b && session.b2b?.savedPostalCode) {
-      sessionStore.set({
-        ...session,
-        postalCode: session.b2b.savedPostalCode,
-      })
-    } else {
-      const sessionWithLocation = await getPostalCode(session)
-      !!sessionWithLocation && sessionStore.set(sessionWithLocation)
-    }
-  }
+  await syncDeliveryPromisePostalCode(session)
 
   try {
     // Prevents to call ValidateSession without session (required) and get Error
@@ -173,12 +190,7 @@ export const validateSession = async (session: Session) => {
 
     return data.validateSession
   } catch (error) {
-    const shouldRefreshToken =
-      !isLocalHostBrowser() &&
-      error?.status === 401 &&
-      storeConfig.experimental?.refreshToken
-
-    if (shouldRefreshToken) {
+    if (error?.status === 401 && canRefreshToken()) {
       const refreshed = await handleRefreshToken(session)
       if (refreshed) {
         sessionStore.set(refreshed)

package/src/server/cms/index.ts

@@ -3,6 +3,7 @@ import ClientCMS from '@vtex/client-cms'
 
 import MultipleContentError from 'src/sdk/error/MultipleContentError'
 import { getStoreURL } from 'src/sdk/localization/useLocalizationConfig'
+import { createPromiseCache } from 'src/server/content/promiseCache'
 import { sanitizeHost } from 'src/utils/utilities'
 import config from '../../../discovery.config'
 
@@ -79,16 +80,64 @@ export const clientCMS = new ClientCMS({
   host: sanitizeHost(new URL(getStoreURL()).origin),
 })
 
+type CMSPageResult = { data: ContentData[] }
+
+export const cmsPageCache = createPromiseCache<CMSPageResult>()
+
+type GetCMSPageOptions = {
+  /**
+   * Reuse a document fetched by locator. Only safe when the locator does not
+   * come from a preview, since preview versions change between requests.
+   */
+  cache?: boolean
+}
+
+/**
+ * Listings by content type never carry preview data (previews always resolve
+ * to a locator), so they are shared across pages. Filtered listings depend on
+ * the page (e.g. landing page slug) and stay uncached.
+ */
 export const getCMSPage = async (
   options: Options,
-  cmsClient: ClientCMS = clientCMS
-) => {
+  cmsClient: ClientCMS = clientCMS,
+  { cache = false }: GetCMSPageOptions = {}
+): Promise<CMSPageResult> => {
+  const shareable = cmsClient === clientCMS
+
   if (isLocator(options)) {
-    return await cmsClient
-      .getCMSPage(options)
-      .then((page) => ({ data: [page] }))
+    const fetchByLocator = () =>
+      cmsClient.getCMSPage(options).then((page) => ({ data: [page] }))
+
+    if (!cache || !shareable) {
+      return fetchByLocator()
+    }
+
+    const { contentType, documentId, versionId, releaseId } = options
+    return cmsPageCache.get(
+      JSON.stringify([
+        'locator',
+        contentType,
+        documentId,
+        versionId,
+        releaseId,
+      ]),
+      fetchByLocator
+    )
+  }
+
+  if (options.filters || !shareable) {
+    return listCMSPages(options, cmsClient)
   }
 
+  return cmsPageCache.get(JSON.stringify(['list', options.contentType]), () =>
+    listCMSPages(options, cmsClient)
+  )
+}
+
+const listCMSPages = async (
+  options: Exclude<Options, Locator>,
+  cmsClient: ClientCMS
+): Promise<CMSPageResult> => {
   const pages = []
   const page = 1
   const perPage = 10
@@ -124,8 +173,11 @@ export const getCMSPage = async (
   return { data: pages }
 }
 
-export const getPage = async <T extends ContentData>(options: Options) => {
-  const result = await getCMSPage(options)
+export const getPage = async <T extends ContentData>(
+  options: Options,
+  getOptions?: GetCMSPageOptions
+) => {
+  const result = await getCMSPage(options, clientCMS, getOptions)
 
   const pages = result.data
 

package/src/server/cms/pdp.ts

@@ -58,11 +58,16 @@ const getPDPFromCmsEnvData = async (
 
   const template = findBestPDPTemplate(pages, product)
 
-  return getPage<PDPContentType>({
-    contentType: 'pdp',
-    documentId: template.documentId as string,
-    versionId: template.versionId,
-  })
+  // The template locator comes from the build-time CMS data, never from a
+  // preview, so the fetched document can be shared across page generations.
+  return getPage<PDPContentType>(
+    {
+      contentType: 'pdp',
+      documentId: template.documentId as string,
+      versionId: template.versionId,
+    },
+    { cache: true }
+  )
 }
 
 const getPDPFromCms = async (

package/src/server/cms/plp.ts

@@ -74,11 +74,16 @@ const getPLPFromCmsEnvData = async (
 
   const template = findBestPLPTemplate(pages, slug, rewrites)
 
-  return getPage<PLPContentType>({
-    contentType: 'plp',
-    documentId: template.documentId as string,
-    versionId: template.versionId,
-  })
+  // The template locator comes from the build-time CMS data, never from a
+  // preview, so the fetched document can be shared across page generations.
+  return getPage<PLPContentType>(
+    {
+      contentType: 'plp',
+      documentId: template.documentId as string,
+      versionId: template.versionId,
+    },
+    { cache: true }
+  )
 }
 
 export const getPLPFromCms = async (

package/src/server/content/promiseCache.ts

@@ -0,0 +1,68 @@
+// Bounds how stale shared CMS content can get in long-lived processes (ISR);
+// a CMS publish already triggers a new build.
+export const CONTENT_CACHE_TTL_MS = 5 * 60 * 1000
+
+type PromiseCacheEntry<T> = {
+  expiresAt: number
+  promise: Promise<T>
+}
+
+/**
+ * Per-process memoization of async loaders. Concurrent callers share the
+ * in-flight promise, entries expire after `ttlMs`, and rejections are evicted
+ * so the next caller retries. When `shouldCache` rejects a resolved value, the
+ * entry is evicted too, so only the callers already waiting share that value.
+ * Expired entries are also dropped whenever a new one is stored, so keys that
+ * are never requested again (e.g. superseded document versions) do not pile up
+ * for the lifetime of the process.
+ */
+export function createPromiseCache<T>(ttlMs = CONTENT_CACHE_TTL_MS) {
+  const entries = new Map<string, PromiseCacheEntry<T>>()
+
+  return {
+    get(
+      key: string,
+      load: () => Promise<T>,
+      shouldCache: (value: T) => boolean = () => true
+    ): Promise<T> {
+      const cached = entries.get(key)
+      if (cached && cached.expiresAt > Date.now()) {
+        return cached.promise
+      }
+
+      const evict = () => {
+        if (entries.get(key)?.promise === promise) {
+          entries.delete(key)
+        }
+      }
+
+      const now = Date.now()
+      entries.forEach((entry, entryKey) => {
+        if (entry.expiresAt <= now) entries.delete(entryKey)
+      })
+
+      const promise = load().then(
+        (value) => {
+          if (!shouldCache(value)) evict()
+          return value
+        },
+        (err: unknown) => {
+          evict()
+          throw err
+        }
+      )
+
+      entries.set(key, { expiresAt: now + ttlMs, promise })
+
+      return promise
+    },
+
+    clear() {
+      entries.clear()
+    },
+
+    get size() {
+      return entries.size
+    },
+  }
+}

package/src/server/content/service.ts

@@ -14,31 +14,29 @@ import {
 import config from '../../../discovery.config'
 import { getPDP, type PDPContentType } from '../cms/pdp'
 import { getPLP, type PLPContentType } from '../cms/plp'
+import { createPromiseCache } from './promiseCache'
 import type { ContentOptions, ContentParams } from './types'
 import { isBranchPreview, isContentPlatformSource } from './utils'
 
-type ContentResult = ContentData | (ContentEntry & PageContentType)
+type ContentResult = ContentData | PageContentType
 
-type ContentListCacheEntry = {
-  expiresAt: number
-  promise: Promise<{ data: ContentResult[] }>
-}
+const CONTENT_AUTHOR_FIELDS = ['createdBy', 'updatedBy'] as const
 
 const OPTIONAL_CONTENT_TYPES = [
   'globalHeaderSections',
   'globalFooterSections',
 ] as const
 
-// Bounds how stale the template list can get in long-lived processes (ISR);
-// a CMS publish already triggers a new build.
-const CONTENT_LIST_CACHE_TTL_MS = 5 * 60 * 1000
-
 export class ContentService {
   private readonly clientCP = new ClientCP({
     tenant: config.api.storeId,
   })
 
-  private readonly contentListCache = new Map<string, ContentListCacheEntry>()
+  private readonly contentListCache = createPromiseCache<{
+    data: ContentResult[]
+  }>()
+
+  private readonly firstEntryCache = createPromiseCache<PageContentType>()
 
   async getSingleContent<T extends ContentData>(
     params: ContentParams
@@ -48,7 +46,7 @@ export class ContentService {
     if (isContentPlatformSource()) {
       return this.getFromCP<T>(options)
     }
-    return getPage(options.cmsOptions)
+    return getPage(options.cmsOptions, { cache: !options.isPreview })
   }
 
   async getMultipleContent(
@@ -134,36 +132,15 @@ export class ContentService {
   private getCachedContentList(
     serviceParams: EntryPathParams
   ): Promise<{ data: ContentResult[] }> {
-    // listEntries only depends on these fields; the page slug must stay out of the key.
-    const { accountName, storeId, contentType, locale } = serviceParams
-    const key = JSON.stringify([accountName, storeId, contentType, locale])
-
-    const cached = this.contentListCache.get(key)
-    if (cached && cached.expiresAt > Date.now()) {
-      return cached.promise
-    }
-
-    const promise = this.listAndFillEntries(serviceParams, false).catch(
-      (err: unknown) => {
-        if (this.contentListCache.get(key)?.promise === promise) {
-          this.contentListCache.delete(key)
-        }
-        throw err
-      }
+    return this.contentListCache.get(getContentTypeKey(serviceParams), () =>
+      this.listAndFillEntries(serviceParams, false)
     )
-
-    this.contentListCache.set(key, {
-      expiresAt: Date.now() + CONTENT_LIST_CACHE_TTL_MS,
-      promise,
-    })
-
-    return promise
   }
 
   private async listAndFillEntries(
     serviceParams: EntryPathParams,
     isPreview: boolean
-  ): Promise<{ data: (ContentEntry & PageContentType)[] }> {
+  ): Promise<{ data: PageContentType[] }> {
     // TODO: This should be temporary until the cp data-plane have a search engine.
     const MAX_PAGES = 25
     const allEntries: ContentEntry[] = []
@@ -189,7 +166,7 @@ export class ContentService {
     entries: ContentEntry[],
     serviceParams: EntryPathParams,
     isPreview: boolean
-  ): Promise<{ data: (ContentEntry & PageContentType)[] }> {
+  ): Promise<{ data: PageContentType[] }> {
     const data = await Promise.all(
       entries.map(async (entry) => {
         const entryData = await this.getEntryData(
@@ -206,9 +183,21 @@ export class ContentService {
     params: EntryPathParams,
     isPreview: boolean
   ): Promise<PageContentType> {
-    return params.entryId || params.slug
-      ? await this.getEntryData(params, isPreview)
-      : await this.fetchFirstEntryFromList(params, isPreview)
+    if (params.entryId || params.slug) {
+      return this.getEntryData(params, isPreview)
+    }
+
+    if (isPreview) {
+      return this.fetchFirstEntryFromList(params, true)
+    }
+
+    // An empty required type is likely content that is about to be published,
+    // so it is not kept for the whole TTL. Optional types are empty by design.
+    return this.firstEntryCache.get(
+      getContentTypeKey(params),
+      () => this.fetchFirstEntryFromList(params, false),
+      (entry) => !isEmptyEntry(entry) || isOptionalContentType(params)
+    )
   }
 
   private async getEntryData(
@@ -220,15 +209,21 @@ export class ContentService {
       throw new Error(`${operation} requires entryId or slug`)
     }
 
+    const entry = await this.loadEntry(params, isPreview)
+
+    return withoutContentAuthorMetadata(entry as PageContentType)
+  }
+
+  private loadEntry(params: EntryPathParams, isPreview: boolean) {
     if (isPreview) {
       return params.entryId
-        ? (this.clientCP.previewEntryById(params) as Promise<PageContentType>)
-        : (this.clientCP.previewEntryBySlug(params) as Promise<PageContentType>)
+        ? this.clientCP.previewEntryById(params)
+        : this.clientCP.previewEntryBySlug(params)
     }
 
     return params.entryId
-      ? (this.clientCP.getEntry(params) as Promise<PageContentType>)
-      : (this.clientCP.getEntryBySlug(params) as Promise<PageContentType>)
+      ? this.clientCP.getEntry(params)
+      : this.clientCP.getEntryBySlug(params)
   }
 
   private async fetchFirstEntryFromList(
@@ -237,11 +232,7 @@ export class ContentService {
   ): Promise<PageContentType> {
     const { entries } = await this.clientCP.listEntries(params)
     if (!entries || entries.length === 0) {
-      const isOptional = OPTIONAL_CONTENT_TYPES.includes(
-        params.contentType as (typeof OPTIONAL_CONTENT_TYPES)[number]
-      )
-
-      if (!isOptional) {
+      if (!isOptionalContentType(params)) {
         console.warn('No entries found for params', params)
       }
       return {} as PageContentType
@@ -341,16 +332,45 @@ export class ContentService {
   private mergeEntryWithData(
     entry: ContentEntry,
     data: PageContentType
-  ): ContentEntry & PageContentType {
+  ): PageContentType {
     return {
-      ...entry,
-      ...data,
+      ...withoutContentAuthorMetadata(data),
       id: entry.id,
       name: entry.name ?? '',
     }
   }
 }
 
+function isOptionalContentType({ contentType }: EntryPathParams): boolean {
+  return OPTIONAL_CONTENT_TYPES.includes(
+    contentType as (typeof OPTIONAL_CONTENT_TYPES)[number]
+  )
+}
+
+function isEmptyEntry(entry: PageContentType): boolean {
+  return Object.keys(entry).length === 0
+}
+
+// listEntries only depends on these fields; the page slug must stay out of the key.
+function getContentTypeKey({
+  accountName,
+  storeId,
+  contentType,
+  locale,
+}: EntryPathParams): string {
+  return JSON.stringify([accountName, storeId, contentType, locale])
+}
+
+function withoutContentAuthorMetadata<T extends object>(value: T): T {
+  const content = { ...value } as Record<string, unknown>
+
+  for (const field of CONTENT_AUTHOR_FIELDS) {
+    delete content[field]
+  }
+
+  return content as T
+}
+
 function isNotFoundError(err: unknown): boolean {
   if (err instanceof MissingContentError) return true
   if (err instanceof Error && /\b404\b/.test(err.message)) return true

package/src/utils/getCheckoutParentDomain.ts

@@ -0,0 +1,53 @@
+import storeConfig from 'discovery.config'
+
+const parseHostname = (url: unknown): string | undefined => {
+  if (typeof url !== 'string' || !url) {
+    return undefined
+  }
+
+  try {
+    return new URL(url).hostname.toLowerCase()
+  } catch {
+    return undefined
+  }
+}
+
+/**
+ * Common parent of the store host and the checkout host (`secureSubdomain`)
+ * when checkout runs on a sibling host: `www.store.com` and `secure.store.com`
+ * share `store.com`.
+ *
+ * Returns `undefined` when a cookie scoped to the store host already reaches
+ * checkout (same host, or checkout on a subdomain of it), and when the hosts
+ * share fewer than two labels.
+ */
+export const getCheckoutParentDomain = (
+  hostname: string
+): string | undefined => {
+  const checkoutHostname = parseHostname(storeConfig.secureSubdomain)
+
+  if (!checkoutHostname) {
+    return undefined
+  }
+
+  const storeLabels = hostname.toLowerCase().split('.').reverse()
+  const checkoutLabels = checkoutHostname.split('.').reverse()
+  const common: string[] = []
+
+  for (
+    let index = 0;
+    index < Math.min(storeLabels.length, checkoutLabels.length) &&
+    storeLabels[index] === checkoutLabels[index];
+    index++
+  ) {
+    common.unshift(storeLabels[index])
+  }
+
+  if (common.length < 2) {
+    return undefined
+  }
+
+  const parent = common.join('.')
+
+  return parent === hostname.toLowerCase() ? undefined : parent
+}

package/src/utils/isLocalHost.ts

@@ -1,9 +1,5 @@
 /**
  * Hostnames that represent a local development environment.
- *
- * These are the only hosts where the FastStore app skips the refresh-token
- * flow so developers can drive the app with a manually injected
- * `VtexIdclientAutCookie_<account>` cookie regardless of feature flags.
  */
 const LOCAL_HOSTNAMES = new Set(['localhost', '127.0.0.1'])
 
@@ -11,9 +7,8 @@ const LOCAL_HOSTNAMES = new Set(['localhost', '127.0.0.1'])
  * Returns `true` when the given hostname corresponds to a local development
  * environment (`localhost` / `127.0.0.1`).
  *
- * Refresh-token and other production-only flows MUST be bypassed on these
- * hostnames so that developers can test logged-in scenarios with manually
- * injected cookies, independent of any experimental flag.
+ * To decide whether to skip the refresh-token flow, use
+ * `shouldBypassRefreshToken`, which also covers WebOps preview hosts.
  *
  * The input MUST be a bare hostname (no port). Use {@link getRequestHostname}
  * on server-side request headers before calling this helper.
@@ -22,12 +17,3 @@ export function isLocalHost(hostname: string | null | undefined): boolean {
   if (!hostname) return false
   return LOCAL_HOSTNAMES.has(hostname.toLowerCase())
 }
-
-/**
- * Browser-side wrapper that reads `window.location.hostname`. Returns `false`
- * when `window` is not available (SSR/Node).
- */
-export function isLocalHostBrowser(): boolean {
-  if (typeof window === 'undefined') return false
-  return isLocalHost(window.location.hostname)
-}