@faststore/core 4.10.1-dev.1 → 4.10.1-dev.3

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/test/server/cms/index.test.ts

@@ -1,5 +1,10 @@
-import { vi } from 'vitest'
-import { clientCMS, getCMSPage } from '../../../src/server/cms'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import {
+  clientCMS,
+  cmsPageCache,
+  getCMSPage,
+  getPage,
+} from '../../../src/server/cms'
 import type { ContentData } from '@vtex/client-cms'
 
 describe('CMS Integration', () => {
@@ -18,15 +23,22 @@ describe('CMS Integration', () => {
     return data
   }
 
+  const mockListing = (count = 1) =>
+    vi.fn((_contentType: string) =>
+      Promise.resolve({
+        data: mockData(count),
+        hasNextPage: false,
+        totalItems: count,
+      })
+    )
+
+  beforeEach(() => {
+    cmsPageCache.clear()
+  })
+
   describe('getCMSPage', () => {
     it('returns the first page if there is only one page', async () => {
-      const mockFunction = vi.fn(() => {
-        return Promise.resolve({
-          data: mockData(3),
-          hasNextPage: false,
-          totalItems: 3,
-        })
-      })
+      const mockFunction = mockListing(3)
       clientCMS.getCMSPagesByContentType = mockFunction
 
       const result = await getCMSPage({ contentType: 'plp' }, clientCMS)
@@ -61,4 +73,85 @@ describe('CMS Integration', () => {
       expect(result.data.length).toBe(15)
     })
   })
+
+  describe('cache', () => {
+    it('shares a content type listing across concurrent callers', async () => {
+      const mockFunction = mockListing(3)
+      clientCMS.getCMSPagesByContentType = mockFunction
+
+      await Promise.all([
+        getCMSPage({ contentType: 'plp' }),
+        getCMSPage({ contentType: 'plp' }),
+        getCMSPage({ contentType: 'plp' }),
+      ])
+      await getCMSPage({ contentType: 'pdp' })
+
+      expect(
+        mockFunction.mock.calls.map(([contentType]) => contentType)
+      ).toEqual(['plp', 'pdp'])
+    })
+
+    it('does not cache filtered listings', async () => {
+      const mockFunction = mockListing(1)
+      clientCMS.getCMSPagesByContentType = mockFunction
+      const options = {
+        contentType: 'landingPage',
+        filters: { 'settings.seo.slug': '/summer-sale' },
+      }
+
+      await getCMSPage(options)
+      await getCMSPage(options)
+
+      expect(mockFunction).toHaveBeenCalledTimes(2)
+    })
+
+    it('fetches a locator on every call by default', async () => {
+      const mockFunction = vi.fn(() => Promise.resolve(mockData(1)[0]))
+      clientCMS.getCMSPage = mockFunction
+      const locator = {
+        contentType: 'globalSections',
+        documentId: 'doc-1',
+        versionId: 'version-1',
+      }
+
+      await getPage(locator)
+      await getPage(locator)
+
+      expect(mockFunction).toHaveBeenCalledTimes(2)
+    })
+
+    it('reuses a locator fetch when caching is enabled', async () => {
+      const mockFunction = vi.fn(() => Promise.resolve(mockData(1)[0]))
+      clientCMS.getCMSPage = mockFunction
+      const locator = {
+        contentType: 'globalSections',
+        documentId: 'doc-1',
+        versionId: 'version-1',
+      }
+
+      const [first, second] = await Promise.all([
+        getPage(locator, { cache: true }),
+        getPage(locator, { cache: true }),
+      ])
+      await getPage({ ...locator, versionId: 'version-2' }, { cache: true })
+
+      expect(first).toEqual(second)
+      expect(mockFunction).toHaveBeenCalledTimes(2)
+    })
+
+    it('does not cache failures', async () => {
+      const error = new Error('Request failed with status code 500')
+      const mockFunction = vi
+        .fn()
+        .mockRejectedValueOnce(error)
+        .mockResolvedValueOnce({ data: mockData(1), totalItems: 1 })
+      clientCMS.getCMSPagesByContentType = mockFunction
+
+      await expect(getCMSPage({ contentType: 'plp' })).rejects.toBe(error)
+      const result = await getCMSPage({ contentType: 'plp' })
+
+      expect(result.data).toHaveLength(1)
+      expect(mockFunction).toHaveBeenCalledTimes(2)
+    })
+  })
 })

package/test/server/content/promiseCache.test.ts

@@ -0,0 +1,150 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+import { createPromiseCache } from '../../../src/server/content/promiseCache'
+
+describe('createPromiseCache', () => {
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  it('shares one in-flight load across concurrent callers', async () => {
+    const cache = createPromiseCache<string>(1000)
+    const load = vi.fn(async () => 'value')
+
+    const results = await Promise.all([
+      cache.get('key', load),
+      cache.get('key', load),
+      cache.get('key', load),
+    ])
+
+    expect(load).toHaveBeenCalledTimes(1)
+    expect(results).toEqual(['value', 'value', 'value'])
+  })
+
+  it('keeps separate entries per key', async () => {
+    const cache = createPromiseCache<string>(1000)
+    const load = vi.fn(async () => 'value')
+
+    await cache.get('a', load)
+    await cache.get('b', load)
+
+    expect(load).toHaveBeenCalledTimes(2)
+  })
+
+  it('loads again after the TTL', async () => {
+    vi.useFakeTimers()
+    const cache = createPromiseCache<string>(1000)
+    const load = vi.fn(async () => 'value')
+
+    await cache.get('key', load)
+    vi.advanceTimersByTime(999)
+    await cache.get('key', load)
+    expect(load).toHaveBeenCalledTimes(1)
+
+    vi.advanceTimersByTime(1)
+    await cache.get('key', load)
+    expect(load).toHaveBeenCalledTimes(2)
+  })
+
+  it('does not cache failures', async () => {
+    const cache = createPromiseCache<string>(1000)
+    const error = new Error('boom')
+    const load = vi
+      .fn<() => Promise<string>>()
+      .mockRejectedValueOnce(error)
+      .mockResolvedValueOnce('value')
+
+    await expect(cache.get('key', load)).rejects.toBe(error)
+    await expect(cache.get('key', load)).resolves.toBe('value')
+    expect(load).toHaveBeenCalledTimes(2)
+  })
+
+  it('does not let a late failure evict a newer load', async () => {
+    vi.useFakeTimers()
+    const cache = createPromiseCache<string>(1000)
+    let rejectFirst: (err: Error) => void = () => {}
+    const load = vi
+      .fn<() => Promise<string>>()
+      .mockImplementationOnce(
+        () =>
+          new Promise((_, reject) => {
+            rejectFirst = reject
+          })
+      )
+      .mockResolvedValue('value')
+
+    const first = cache.get('key', load)
+    const firstResult = expect(first).rejects.toThrow('late failure')
+    vi.advanceTimersByTime(1000)
+    await cache.get('key', load)
+
+    rejectFirst(new Error('late failure'))
+    await firstResult
+    await cache.get('key', load)
+
+    expect(load).toHaveBeenCalledTimes(2)
+  })
+
+  it('does not keep values rejected by shouldCache', async () => {
+    const cache = createPromiseCache<string>(1000)
+    const load = vi.fn(async () => '')
+    const shouldCache = (value: string) => value !== ''
+
+    const concurrent = await Promise.all([
+      cache.get('key', load, shouldCache),
+      cache.get('key', load, shouldCache),
+    ])
+    await cache.get('key', load, shouldCache)
+
+    expect(concurrent).toEqual(['', ''])
+    expect(load).toHaveBeenCalledTimes(2)
+  })
+
+  it('keeps values accepted by shouldCache', async () => {
+    const cache = createPromiseCache<string>(1000)
+    const load = vi.fn(async () => 'value')
+
+    await cache.get('key', load, (value) => value !== '')
+    await cache.get('key', load, (value) => value !== '')
+
+    expect(load).toHaveBeenCalledTimes(1)
+  })
+
+  it('drops expired entries when a new key is stored', async () => {
+    vi.useFakeTimers()
+    const cache = createPromiseCache<string>(1000)
+    const load = vi.fn(async () => 'value')
+
+    await cache.get('old-version', load)
+    await cache.get('other', load)
+    expect(cache.size).toBe(2)
+
+    vi.advanceTimersByTime(1000)
+    await cache.get('new-version', load)
+
+    expect(cache.size).toBe(1)
+  })
+
+  it('keeps entries that have not expired when a new key is stored', async () => {
+    vi.useFakeTimers()
+    const cache = createPromiseCache<string>(1000)
+    const load = vi.fn(async () => 'value')
+
+    await cache.get('a', load)
+    vi.advanceTimersByTime(999)
+    await cache.get('b', load)
+
+    expect(cache.size).toBe(2)
+  })
+
+  it('drops every entry on clear', async () => {
+    const cache = createPromiseCache<string>(1000)
+    const load = vi.fn(async () => 'value')
+
+    await cache.get('key', load)
+    cache.clear()
+    await cache.get('key', load)
+
+    expect(load).toHaveBeenCalledTimes(2)
+  })
+})