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

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