@faststore/core 4.10.1 → 4.10.2

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)
+  })
+})

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

@@ -1,22 +1,45 @@
 import type { ContentEntry, EntryPathParams } from '@vtex/client-cp'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
+import { clientCMS, cmsPageCache } from '../../../src/server/cms'
 import { ContentService } from '../../../src/server/content/service'
-import type {
-  ContentOptions,
-  ContentParams,
+import {
+  type ContentOptions,
+  type ContentParams,
+  ContentSourceType,
 } from '../../../src/server/content/types'
-import type * as ContentUtils from '../../../src/server/content/utils'
-import { isContentPlatformSource } from '../../../src/server/content/utils'
+import { contentSource } from '../../../discovery.config'
+
+type ContentSourceConfig = { type: string }
+type DiscoveryConfigModule = {
+  default: Record<string, unknown>
+  contentSource: ContentSourceConfig
+}
+
+vi.mock('../../../discovery.config', async (importOriginal) => {
+  const actual = await importOriginal<DiscoveryConfigModule>()
+  const base = actual.default ?? actual
+  const mutableContentSource = {
+    ...(base.contentSource as ContentSourceConfig),
+  }
 
-vi.mock('../../../src/server/content/utils', async (importOriginal) => {
-  const actual = await importOriginal<typeof ContentUtils>()
   return {
     ...actual,
-    isContentPlatformSource: vi.fn(actual.isContentPlatformSource),
+    default: { ...base, contentSource: mutableContentSource },
+    contentSource: mutableContentSource,
   }
 })
 
+const DEFAULT_CONTENT_SOURCE_TYPE = contentSource.type
+
+const useContentPlatform = () => {
+  contentSource.type = ContentSourceType.ContentPlatform
+}
+
+const useHeadlessCms = () => {
+  contentSource.type = DEFAULT_CONTENT_SOURCE_TYPE
+}
+
 type ContentServiceInternals = {
   createContentOptions: (params: ContentParams) => ContentOptions
   convertOptionsToParams: (options: ContentOptions) => EntryPathParams
@@ -39,7 +62,17 @@ const entryData: Record<string, Record<string, unknown>> = {
   },
 }
 
-const toEntry = (id: string) => ({ id, name: id }) as ContentEntry
+const toEntry = (id: string): ContentEntry => ({
+  id,
+  name: id,
+  account: 'example-account',
+  storeId: 'faststore',
+  createdAt: '2026-01-01T00:00:00.000Z',
+  updatedAt: '2026-01-02T00:00:00.000Z',
+  createdBy: 'editor@example.com',
+  updatedBy: 'other@example.com',
+  slug: id,
+})
 
 function createFakeClientCP(pages: string[][]) {
   return {
@@ -52,6 +85,8 @@ function createFakeClientCP(pages: string[][]) {
     }),
     getEntry: vi.fn(async ({ entryId }: EntryPathParams) => ({
       ...entryData[entryId as string],
+      createdBy: 'payload@example.com',
+      updatedBy: 'payload@example.com',
     })),
     previewEntryById: vi.fn(async ({ entryId }: EntryPathParams) => ({
       ...entryData[entryId as string],
@@ -163,16 +198,43 @@ describe('ContentService', () => {
     const FIVE_MINUTES = 5 * 60 * 1000
 
     beforeEach(() => {
-      vi.mocked(isContentPlatformSource).mockReturnValue(true)
+      useContentPlatform()
       vi.spyOn(console, 'warn').mockImplementation(() => {})
     })
 
     afterEach(() => {
-      vi.mocked(isContentPlatformSource).mockReset()
+      useHeadlessCms()
       vi.restoreAllMocks()
       vi.useRealTimers()
     })
 
+    it('keeps Content Platform author emails out of public page content', async () => {
+      const { service, clientCP } = createServiceWithClient()
+      clientCP.getEntryBySlug.mockResolvedValueOnce({
+        sections: [{ name: 'Direct' }],
+        createdBy: 'editor@example.com',
+        updatedBy: 'other@example.com',
+      })
+
+      const directPage = await service.getSingleContent({
+        contentType: 'pdp',
+        slug: 'product-slug',
+      })
+      const { data } = await service.getMultipleContent({ contentType: 'pdp' })
+      const listedPage = data[0]
+
+      expect(directPage.sections).toEqual([{ name: 'Direct' }])
+      expect(directPage).not.toHaveProperty('createdBy')
+      expect(directPage).not.toHaveProperty('updatedBy')
+      expect(listedPage.id).toBe('generic')
+      expect(listedPage.name).toBe('generic')
+      expect(listedPage.sections).toEqual([{ name: 'Generic' }])
+      expect(listedPage).not.toHaveProperty('createdBy')
+      expect(listedPage).not.toHaveProperty('updatedBy')
+      expect(listedPage).not.toHaveProperty('account')
+      expect(listedPage).not.toHaveProperty('storeId')
+    })
+
     it('shares one list and entry fetch across concurrent PLPs with different slugs', async () => {
       const { service, clientCP } = createServiceWithClient()
 
@@ -334,4 +396,208 @@ describe('ContentService', () => {
       expect(clientCP.listEntries).toHaveBeenCalledTimes(2)
     })
   })
+
+  describe('Content Platform single entry cache', () => {
+    const FIVE_MINUTES = 5 * 60 * 1000
+
+    beforeEach(() => {
+      useContentPlatform()
+      vi.spyOn(console, 'warn').mockImplementation(() => {})
+    })
+
+    afterEach(() => {
+      useHeadlessCms()
+      vi.restoreAllMocks()
+      vi.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 and locale', async () => {
+      const { service, clientCP } = createServiceWithClient([['generic']])
+
+      await service.getSingleContent({ contentType: 'globalSections' })
+      await service.getSingleContent({ contentType: 'globalHeaderSections' })
+      await service.getSingleContent({
+        contentType: 'globalSections',
+        locale: 'en-US',
+      })
+      await service.getSingleContent({ contentType: 'globalSections' })
+
+      expect(
+        clientCP.listEntries.mock.calls.map(([params]) => [
+          params.contentType,
+          params.locale,
+        ])
+      ).toEqual([
+        ['globalSections', undefined],
+        ['globalHeaderSections', undefined],
+        ['globalSections', 'en-US'],
+      ])
+    })
+
+    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('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 () => {
+      vi.useFakeTimers()
+      const { service, clientCP } = createServiceWithClient([['generic']])
+
+      await service.getSingleContent({ contentType: 'globalSections' })
+      vi.advanceTimersByTime(FIVE_MINUTES)
+      await service.getSingleContent({ contentType: 'globalSections' })
+
+      expect(clientCP.listEntries).toHaveBeenCalledTimes(2)
+    })
+  })
+
+  describe('Headless CMS single content cache', () => {
+    const locator = {
+      contentType: 'globalSections',
+      documentId: 'doc-1',
+      versionId: 'version-1',
+    }
+
+    beforeEach(() => {
+      useHeadlessCms()
+      cmsPageCache.clear()
+      vi.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(() => {
+      useHeadlessCms()
+      vi.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/test/utils/shouldBypassRefreshToken.browser.test.ts

@@ -0,0 +1,38 @@
+import { afterEach, describe, expect, it } from 'vitest'
+import { shouldBypassRefreshTokenBrowser } from '../../src/utils/shouldBypassRefreshToken'
+
+const originalLocation = window.location
+
+function stubHostname(hostname: string) {
+  // jsdom forbids assigning to `window.location` directly, so we redefine the
+  // descriptor with a minimal stub that exposes the hostname we want to test.
+  Object.defineProperty(window, 'location', {
+    configurable: true,
+    value: { ...originalLocation, hostname },
+  })
+}
+
+describe('shouldBypassRefreshTokenBrowser', () => {
+  afterEach(() => {
+    Object.defineProperty(window, 'location', {
+      configurable: true,
+      value: originalLocation,
+    })
+  })
+
+  it.each(['localhost', '127.0.0.1', 'brandless-abc123.preview.vtex.app'])(
+    'returns true when window.location.hostname is "%s"',
+    (hostname) => {
+      stubHostname(hostname)
+      expect(shouldBypassRefreshTokenBrowser()).toBe(true)
+    }
+  )
+
+  it.each(['brandless.vtex.app', 'brandless.fast.store'])(
+    'returns false for the production hostname "%s"',
+    (hostname) => {
+      stubHostname(hostname)
+      expect(shouldBypassRefreshTokenBrowser()).toBe(false)
+    }
+  )
+})