@faststore/core 3.100.7 → 3.100.9

package/src/server/content/service.ts

@@ -15,23 +15,24 @@ import MissingContentError from 'src/sdk/error/MissingContentError'
 import { getPDP, type PDPContentType } from '../cms/pdp'
 import MultipleContentError from 'src/sdk/error/MultipleContentError'
 import type { ServerProductQueryQuery } from '@generated/graphql'
+import { createPromiseCache } from './promiseCache'
 import { isBranchPreview, isContentPlatformSource } from './utils'
 
 type ContentResult = ContentData | (ContentEntry & PageContentType)
 
-type ContentListCacheEntry = {
-  expiresAt: number
-  promise: Promise<{ data: ContentResult[] }>
-}
-
-// 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
+const OPTIONAL_CONTENT_TYPES = [
+  'globalHeaderSections',
+  'globalFooterSections',
+] as const
 
 export class ContentService {
   private clientCP: ClientCP
 
-  private readonly contentListCache = new Map<string, ContentListCacheEntry>()
+  private readonly contentListCache = createPromiseCache<{
+    data: ContentResult[]
+  }>()
+
+  private readonly firstEntryCache = createPromiseCache<PageContentType>()
 
   constructor() {
     this.clientCP = new ClientCP({
@@ -47,7 +48,7 @@ export class ContentService {
     if (isContentPlatformSource()) {
       return this.getFromCP<T>(options)
     }
-    return getPage(options.cmsOptions)
+    return getPage(options.cmsOptions, { cache: !options.isPreview })
   }
 
   async getMultipleContent(
@@ -118,10 +119,15 @@ export class ContentService {
     options: ContentOptions
   ): Promise<T> {
     const params = this.convertOptionsToParams(options)
+    // Filters are forwarded to listEntries, so a filtered lookup is not shared.
+    const shareable =
+      !options.isPreview &&
+      !('filters' in options.cmsOptions && options.cmsOptions.filters)
     try {
       const entry: PageContentType = await this.getEntry(
         params,
-        options.isPreview
+        options.isPreview,
+        shareable
       )
       return entry as T
     } catch (err: unknown) {
@@ -133,30 +139,9 @@ 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(
@@ -203,11 +188,24 @@ export class ContentService {
 
   private async getEntry(
     params: EntryPathParams,
-    isPreview: boolean
+    isPreview: boolean,
+    shareable: 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 (!shareable) {
+      return this.fetchFirstEntryFromList(params, isPreview)
+    }
+
+    // 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(
@@ -338,6 +336,26 @@ export class ContentService {
   }
 }
 
+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 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,4 +1,9 @@
-import { clientCMS, getCMSPage } from '../../../src/server/cms'
+import {
+  clientCMS,
+  cmsPageCache,
+  getCMSPage,
+  getPage,
+} from '../../../src/server/cms'
 import { jest } from '@jest/globals'
 import type { ContentData } from '@vtex/client-cms'
 
@@ -18,15 +23,32 @@ describe('CMS Integration', () => {
     return data
   }
 
+  const mockListing = (count = 1) => {
+    const mockFunction: jest.Mock<typeof clientCMS.getCMSPagesByContentType> =
+      jest.fn()
+    mockFunction.mockImplementation(() =>
+      Promise.resolve({
+        data: mockData(count),
+        hasNextPage: false,
+        totalItems: count,
+      })
+    )
+    return mockFunction
+  }
+
+  const mockLocator = () => {
+    const mockFunction: jest.Mock<typeof clientCMS.getCMSPage> = jest.fn()
+    mockFunction.mockImplementation(() => Promise.resolve(mockData(1)[0]))
+    return mockFunction
+  }
+
+  beforeEach(() => {
+    cmsPageCache.clear()
+  })
+
   describe('getCMSPage', () => {
     it('returns the first page if there is only one page', async () => {
-      const mockFunction = jest.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)
@@ -62,4 +84,86 @@ 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: { 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 = mockLocator()
+      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 = mockLocator()
+      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: jest.Mock<typeof clientCMS.getCMSPagesByContentType> =
+        jest.fn()
+      mockFunction
+        .mockRejectedValueOnce(error)
+        .mockResolvedValueOnce({ data: mockData(1), totalItems: 1 } as never)
+      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 { jest } from '@jest/globals'
+
+import { createPromiseCache } from '../../../src/server/content/promiseCache'
+
+describe('createPromiseCache', () => {
+  afterEach(() => {
+    jest.useRealTimers()
+  })
+
+  it('shares one in-flight load across concurrent callers', async () => {
+    const cache = createPromiseCache<string>(1000)
+    const load = jest.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 = jest.fn(async () => 'value')
+
+    await cache.get('a', load)
+    await cache.get('b', load)
+
+    expect(load).toHaveBeenCalledTimes(2)
+  })
+
+  it('loads again after the TTL', async () => {
+    jest.useFakeTimers()
+    const cache = createPromiseCache<string>(1000)
+    const load = jest.fn(async () => 'value')
+
+    await cache.get('key', load)
+    jest.advanceTimersByTime(999)
+    await cache.get('key', load)
+    expect(load).toHaveBeenCalledTimes(1)
+
+    jest.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 = jest
+      .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 () => {
+    jest.useFakeTimers()
+    const cache = createPromiseCache<string>(1000)
+    let rejectFirst: (err: Error) => void = () => {}
+    const load = jest
+      .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')
+    jest.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 = jest.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 = jest.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 () => {
+    jest.useFakeTimers()
+    const cache = createPromiseCache<string>(1000)
+    const load = jest.fn(async () => 'value')
+
+    await cache.get('old-version', load)
+    await cache.get('other', load)
+    expect(cache.size).toBe(2)
+
+    jest.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 () => {
+    jest.useFakeTimers()
+    const cache = createPromiseCache<string>(1000)
+    const load = jest.fn(async () => 'value')
+
+    await cache.get('a', load)
+    jest.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 = jest.fn(async () => 'value')
+
+    await cache.get('key', load)
+    cache.clear()
+    await cache.get('key', load)
+
+    expect(load).toHaveBeenCalledTimes(2)
+  })
+})

package/test/server/content/service.test.ts

@@ -1,12 +1,35 @@
 import type { ContentEntry, EntryPathParams } from '@vtex/client-cp'
 
+import { contentSource } from '../../../discovery.config'
+import { clientCMS, cmsPageCache } from '../../../src/server/cms'
 import { ContentService } from '../../../src/server/content/service'
-import type { ContentParams } from '../../../src/server/content/types'
+import {
+  type ContentParams,
+  ContentSourceType,
+} from '../../../src/server/content/types'
 
-jest.mock('../../../src/server/content/utils', () => ({
-  ...jest.requireActual('../../../src/server/content/utils'),
-  isContentPlatformSource: jest.fn(() => true),
-}))
+jest.mock('../../../discovery.config', () => {
+  const actual = jest.requireActual('../../../discovery.config')
+  const base = actual.default ?? actual
+  const mutableContentSource = { ...base.contentSource }
+
+  return {
+    __esModule: true,
+    ...actual,
+    default: { ...base, contentSource: mutableContentSource },
+    contentSource: mutableContentSource,
+  }
+})
+
+const DEFAULT_CONTENT_SOURCE_TYPE = contentSource.type
+
+beforeEach(() => {
+  contentSource.type = ContentSourceType.ContentPlatform
+})
+
+afterAll(() => {
+  contentSource.type = DEFAULT_CONTENT_SOURCE_TYPE
+})
 
 const NOT_FOUND = 'Request failed with status code 404'
 const FIVE_MINUTES = 5 * 60 * 1000
@@ -220,3 +243,204 @@ describe('ContentService Content Platform template list cache', () => {
     expect(clientCP.listEntries).toHaveBeenCalledTimes(2)
   })
 })
+
+describe('ContentService Content Platform single entry cache', () => {
+  beforeEach(() => {
+    jest.spyOn(console, 'warn').mockImplementation(() => {})
+  })
+
+  afterEach(() => {
+    jest.restoreAllMocks()
+    jest.useRealTimers()
+  })
+
+  it('shares one list and entry fetch across concurrent pages', async () => {
+    const { service, clientCP } = createServiceWithClient([['generic']])
+
+    const results = await Promise.all(
+      Array.from({ length: 20 }, () =>
+        service.getSingleContent({ contentType: 'globalSections' })
+      )
+    )
+
+    expect(clientCP.listEntries).toHaveBeenCalledTimes(1)
+    expect(clientCP.getEntry).toHaveBeenCalledTimes(1)
+    for (const result of results) {
+      expect(result.sections).toEqual([{ name: 'Generic' }])
+    }
+  })
+
+  it('keeps separate entries per content type', async () => {
+    const { service, clientCP } = createServiceWithClient([['generic']])
+
+    await service.getSingleContent({ contentType: 'globalSections' })
+    await service.getSingleContent({ contentType: 'globalHeaderSections' })
+    await service.getSingleContent({ contentType: 'globalSections' })
+
+    expect(
+      clientCP.listEntries.mock.calls.map(([params]) => params.contentType)
+    ).toEqual(['globalSections', 'globalHeaderSections'])
+  })
+
+  it('caches an empty optional content type', async () => {
+    const { service, clientCP } = createServiceWithClient([[]])
+
+    const first = await service.getSingleContent({
+      contentType: 'globalFooterSections',
+    })
+    await service.getSingleContent({ contentType: 'globalFooterSections' })
+
+    expect(first).toEqual({})
+    expect(clientCP.listEntries).toHaveBeenCalledTimes(1)
+    expect(clientCP.getEntry).not.toHaveBeenCalled()
+  })
+
+  it('does not cache an empty required content type', async () => {
+    const { service, clientCP } = createServiceWithClient([[]])
+
+    const first = await service.getSingleContent({
+      contentType: 'globalSections',
+    })
+    await service.getSingleContent({ contentType: 'globalSections' })
+
+    expect(first).toEqual({})
+    expect(clientCP.listEntries).toHaveBeenCalledTimes(2)
+  })
+
+  it('picks up a required content type published after an empty lookup', async () => {
+    const { service, clientCP } = createServiceWithClient([['generic']])
+    clientCP.listEntries.mockResolvedValueOnce({ entries: [], scroll: null })
+
+    const before = await service.getSingleContent({
+      contentType: 'globalSections',
+    })
+    const after = await service.getSingleContent({
+      contentType: 'globalSections',
+    })
+    await service.getSingleContent({ contentType: 'globalSections' })
+
+    expect(before).toEqual({})
+    expect(after.sections).toEqual([{ name: 'Generic' }])
+    expect(clientCP.listEntries).toHaveBeenCalledTimes(2)
+  })
+
+  it('does not cache lookups by slug', async () => {
+    const { service, clientCP } = createServiceWithClient([['generic']])
+
+    await service.getSingleContent({ contentType: 'landingPage', slug: 'a' })
+    await service.getSingleContent({ contentType: 'landingPage', slug: 'a' })
+
+    expect(clientCP.getEntryBySlug).toHaveBeenCalledTimes(2)
+    expect(clientCP.listEntries).not.toHaveBeenCalled()
+  })
+
+  it('does not cache filtered lookups', async () => {
+    const { service, clientCP } = createServiceWithClient([['generic']])
+    const params: ContentParams = {
+      contentType: 'globalSections',
+      filters: { page: 1 },
+    }
+
+    await service.getSingleContent(params)
+    await service.getSingleContent(params)
+
+    expect(clientCP.listEntries).toHaveBeenCalledTimes(2)
+  })
+
+  it('bypasses the cache for branch previews', async () => {
+    const { service, clientCP } = createServiceWithClient([['generic']])
+    const branchPreview: ContentParams = {
+      contentType: 'globalSections',
+      previewData: {
+        contentType: 'landingPage',
+        documentId: 'some-landing-page',
+        versionId: 'branch-1',
+      },
+    }
+
+    await service.getSingleContent({ contentType: 'globalSections' })
+    await service.getSingleContent(branchPreview)
+    await service.getSingleContent(branchPreview)
+    await service.getSingleContent({ contentType: 'globalSections' })
+
+    expect(clientCP.listEntries).toHaveBeenCalledTimes(3)
+    expect(clientCP.getEntry).toHaveBeenCalledTimes(1)
+    expect(clientCP.previewEntryById).toHaveBeenCalledTimes(2)
+  })
+
+  it('does not cache a multiple-entries error', async () => {
+    const { service, clientCP } = createServiceWithClient([
+      ['generic', 'collection'],
+    ])
+
+    await expect(
+      service.getSingleContent({ contentType: 'globalSections' })
+    ).rejects.toThrow()
+    await expect(
+      service.getSingleContent({ contentType: 'globalSections' })
+    ).rejects.toThrow()
+
+    expect(clientCP.listEntries).toHaveBeenCalledTimes(2)
+  })
+
+  it('fetches again after the TTL', async () => {
+    jest.useFakeTimers()
+    const { service, clientCP } = createServiceWithClient([['generic']])
+
+    await service.getSingleContent({ contentType: 'globalSections' })
+    jest.advanceTimersByTime(FIVE_MINUTES)
+    await service.getSingleContent({ contentType: 'globalSections' })
+
+    expect(clientCP.listEntries).toHaveBeenCalledTimes(2)
+  })
+})
+
+describe('ContentService Headless CMS single content cache', () => {
+  const locator = {
+    contentType: 'globalSections',
+    documentId: 'doc-1',
+    versionId: 'version-1',
+  }
+
+  beforeEach(() => {
+    contentSource.type = DEFAULT_CONTENT_SOURCE_TYPE
+    cmsPageCache.clear()
+    jest.spyOn(clientCMS, 'getCMSPage').mockResolvedValue({
+      id: 'doc-1',
+      name: 'doc-1',
+      status: 'published',
+      type: 'globalSections',
+      releaseId: 'release-1',
+      sections: [{ name: 'Children' }],
+    } as Awaited<ReturnType<typeof clientCMS.getCMSPage>>)
+  })
+
+  afterEach(() => {
+    jest.restoreAllMocks()
+  })
+
+  it('reuses a published document fetched by locator', async () => {
+    const service = new ContentService()
+
+    await Promise.all([
+      service.getSingleContent(locator),
+      service.getSingleContent(locator),
+    ])
+    await service.getSingleContent(locator)
+
+    expect(clientCMS.getCMSPage).toHaveBeenCalledTimes(1)
+  })
+
+  it('fetches the document on every preview request', async () => {
+    const service = new ContentService()
+    const previewParams: ContentParams = {
+      ...locator,
+      previewData: locator,
+    }
+
+    await service.getSingleContent(previewParams)
+    await service.getSingleContent(previewParams)
+
+    expect(clientCMS.getCMSPage).toHaveBeenCalledTimes(2)
+  })
+})

package/.next/cache/config.json

@@ -1,7 +0,0 @@
-{
-	"telemetry": {
-		"notifiedAt": "1793052786162",
-		"anonymousId": "f9a3a0a50abf991b84a56c57c91a24593d9a11e7d1f9840e9a950611f78982b1",
-		"salt": "4d3d2e48c23dc357f87442f0237d9ba6"
-	}
-}