@faststore/core 3.99.1 → 4.0.0-dev.4

package/test/sdk/search/useSearchHistory.test.ts

@@ -0,0 +1,222 @@
+/**
+ * @vitest-environment jsdom
+ */
+
+import { act, renderHook } from '@testing-library/react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+vi.mock('discovery.config', () => ({
+  __esModule: true,
+  default: {
+    localization: { enabled: false, defaultLocale: 'pt-BR' },
+    session: { locale: 'en-US' },
+  },
+}))
+
+const mockUseSession = vi.hoisted(() => vi.fn(() => ({ locale: 'pt-BR' })))
+vi.mock('src/sdk/session', () => ({ useSession: mockUseSession }))
+
+import {
+  searchHistoryStore,
+  type History,
+} from '../../../src/sdk/search/useSearchHistory'
+import useSearchHistory from '../../../src/sdk/search/useSearchHistory'
+
+function makeHistory(term: string, path = `/s?q=${term}`) {
+  return { term, path } satisfies History
+}
+
+describe('useSearchHistory', () => {
+  beforeEach(() => {
+    searchHistoryStore.set({})
+    mockUseSession.mockReturnValue({ locale: 'pt-BR' })
+  })
+
+  afterEach(() => {
+    vi.clearAllMocks()
+  })
+
+  describe('searchHistory (read by locale)', () => {
+    it('returns empty array when store is empty', () => {
+      const { result } = renderHook(() => useSearchHistory())
+      expect(result.current.searchHistory).toEqual([])
+    })
+
+    it('returns history for current locale when store has data for that locale', () => {
+      const items = [makeHistory('tenis'), makeHistory('camisa')]
+      searchHistoryStore.set({ 'pt-BR': items })
+
+      const { result } = renderHook(() => useSearchHistory())
+      expect(result.current.searchHistory).toEqual(items)
+    })
+
+    it('returns empty array when store has data only for another locale', () => {
+      searchHistoryStore.set({
+        'en-US': [makeHistory('shoes')],
+      })
+
+      const { result } = renderHook(() => useSearchHistory())
+      expect(result.current.searchHistory).toEqual([])
+    })
+
+    it('uses session locale and shows correct slice when locale changes', () => {
+      searchHistoryStore.set({
+        'pt-BR': [makeHistory('tenis')],
+        'en-US': [makeHistory('shoes')],
+      })
+
+      const { result, rerender } = renderHook(() => useSearchHistory())
+      expect(result.current.searchHistory).toEqual([makeHistory('tenis')])
+
+      mockUseSession.mockReturnValue({ locale: 'en-US' })
+      rerender()
+      expect(result.current.searchHistory).toEqual([makeHistory('shoes')])
+    })
+  })
+
+  describe('addToSearchHistory', () => {
+    it('adds item to current locale and persists', () => {
+      const { result } = renderHook(() => useSearchHistory())
+
+      act(() => {
+        result.current.addToSearchHistory(makeHistory('tenis'))
+      })
+
+      expect(result.current.searchHistory).toHaveLength(1)
+      expect(result.current.searchHistory[0].term).toBe('tenis')
+      expect(searchHistoryStore.read()).toEqual({
+        'pt-BR': [makeHistory('tenis')],
+      })
+    })
+
+    it('dedupes by term and moves to front', () => {
+      searchHistoryStore.set({
+        'pt-BR': [makeHistory('camisa'), makeHistory('tenis')],
+      })
+      const { result } = renderHook(() => useSearchHistory())
+
+      act(() => {
+        result.current.addToSearchHistory(
+          makeHistory('tenis', '/s?q=tenis&sort=score_desc')
+        )
+      })
+
+      expect(result.current.searchHistory.map((h) => h.term)).toEqual([
+        'tenis',
+        'camisa',
+      ])
+      expect(result.current.searchHistory).toHaveLength(2)
+    })
+
+    it('respects maxHistorySize (default 4)', () => {
+      const { result } = renderHook(() => useSearchHistory())
+
+      act(() => result.current.addToSearchHistory(makeHistory('a')))
+      act(() => result.current.addToSearchHistory(makeHistory('b')))
+      act(() => result.current.addToSearchHistory(makeHistory('c')))
+      act(() => result.current.addToSearchHistory(makeHistory('d')))
+      act(() => result.current.addToSearchHistory(makeHistory('e')))
+
+      expect(result.current.searchHistory).toHaveLength(4)
+      expect(result.current.searchHistory.map((h) => h.term)).toEqual([
+        'e',
+        'd',
+        'c',
+        'b',
+      ])
+    })
+
+    it('can use custom maxHistorySize', () => {
+      const { result } = renderHook(() => useSearchHistory(2))
+
+      act(() => result.current.addToSearchHistory(makeHistory('a')))
+      act(() => result.current.addToSearchHistory(makeHistory('b')))
+      act(() => result.current.addToSearchHistory(makeHistory('c')))
+
+      expect(result.current.searchHistory).toHaveLength(2)
+      expect(result.current.searchHistory.map((h) => h.term)).toEqual([
+        'c',
+        'b',
+      ])
+    })
+
+    it('does not affect other locales', () => {
+      searchHistoryStore.set({
+        'en-US': [makeHistory('shoes')],
+      })
+      const { result } = renderHook(() => useSearchHistory())
+
+      act(() => {
+        result.current.addToSearchHistory(makeHistory('tenis'))
+      })
+
+      expect(searchHistoryStore.read()).toEqual({
+        'en-US': [makeHistory('shoes')],
+        'pt-BR': [makeHistory('tenis')],
+      })
+    })
+  })
+
+  describe('clearSearchHistory', () => {
+    it('removes only current locale and leaves others', () => {
+      searchHistoryStore.set({
+        'pt-BR': [makeHistory('tenis')],
+        'en-US': [makeHistory('shoes')],
+      })
+      const { result } = renderHook(() => useSearchHistory())
+
+      act(() => {
+        result.current.clearSearchHistory()
+      })
+
+      expect(result.current.searchHistory).toEqual([])
+      expect(searchHistoryStore.read()).toEqual({
+        'en-US': [makeHistory('shoes')],
+      })
+    })
+
+    it('sets store to empty object when clearing last locale', () => {
+      searchHistoryStore.set({ 'pt-BR': [makeHistory('tenis')] })
+      const { result } = renderHook(() => useSearchHistory())
+
+      act(() => {
+        result.current.clearSearchHistory()
+      })
+
+      expect(searchHistoryStore.read()).toEqual({})
+    })
+  })
+
+  describe('legacy format (array) migration', () => {
+    it('normalizes array to Record with default locale and exposes as searchHistory when session matches default', () => {
+      const legacy = [makeHistory('old1'), makeHistory('old2')]
+      searchHistoryStore.set(legacy as unknown as Record<string, History[]>)
+      mockUseSession.mockReturnValue({ locale: 'en-US' })
+
+      const { result } = renderHook(() => useSearchHistory())
+
+      expect(result.current.searchHistory).toHaveLength(2)
+      expect(result.current.searchHistory.map((h) => h.term)).toEqual([
+        'old1',
+        'old2',
+      ])
+    })
+
+    it('after migration persists Record so store no longer holds array', async () => {
+      const legacy = [makeHistory('old1')]
+      searchHistoryStore.set(legacy as unknown as Record<string, History[]>)
+      mockUseSession.mockReturnValue({ locale: 'en-US' })
+
+      renderHook(() => useSearchHistory())
+
+      await act(async () => {
+        await Promise.resolve()
+      })
+
+      const stored = searchHistoryStore.read()
+      expect(Array.isArray(stored)).toBe(false)
+      expect(stored).toHaveProperty('en-US')
+      expect((stored as Record<string, History[]>)['en-US']).toHaveLength(1)
+    })
+  })
+})

package/test/server/cms/index.test.ts

@@ -1,5 +1,5 @@
+import { vi } from 'vitest'
 import { clientCMS, getCMSPage } from '../../../src/server/cms'
-import { jest } from '@jest/globals'
 import type { ContentData } from '@vtex/client-cms'
 
 describe('CMS Integration', () => {
@@ -20,7 +20,7 @@ describe('CMS Integration', () => {
 
   describe('getCMSPage', () => {
     it('returns the first page if there is only one page', async () => {
-      const mockFunction = jest.fn(() => {
+      const mockFunction = vi.fn(() => {
         return Promise.resolve({
           data: mockData(3),
           hasNextPage: false,
@@ -36,8 +36,7 @@ describe('CMS Integration', () => {
     })
 
     it('loads multiple pages', async () => {
-      const mockFunction: jest.Mock<typeof clientCMS.getCMSPagesByContentType> =
-        jest.fn()
+      const mockFunction = vi.fn()
 
       mockFunction.mockImplementationOnce(() => {
         return Promise.resolve({

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

@@ -0,0 +1,98 @@
+import type { EntryPathParams } from '@vtex/client-cp'
+import { describe, expect, it } from 'vitest'
+
+import { ContentService } from '../../../src/server/content/service'
+import type {
+  ContentOptions,
+  ContentParams,
+} from '../../../src/server/content/types'
+
+type ContentServiceInternals = {
+  createContentOptions: (params: ContentParams) => ContentOptions
+  convertOptionsToParams: (options: ContentOptions) => EntryPathParams
+}
+
+const getServiceInternals = (service: ContentService) =>
+  service as unknown as ContentServiceInternals
+
+describe('ContentService', () => {
+  describe('convertOptionsToParams', () => {
+    it('maps a flat SEO slug filter to the client-cp slug param', () => {
+      const service = getServiceInternals(new ContentService())
+      const options = service.createContentOptions({
+        contentType: 'landingPage',
+        filters: { 'settings.seo.slug': '/summer-sale' },
+      })
+
+      const params = service.convertOptionsToParams(options)
+
+      expect(params.slug).toBe('summer-sale')
+    })
+
+    it('keeps an explicit slug when filters also include settings.seo.slug', () => {
+      const service = getServiceInternals(new ContentService())
+      const options = service.createContentOptions({
+        contentType: 'landingPage',
+        slug: 'summer-sale',
+        filters: { 'settings.seo.slug': '/other-slug' },
+      })
+
+      const params = service.convertOptionsToParams(options)
+
+      expect(params.slug).toBe('summer-sale')
+    })
+  })
+
+  describe('createContentOptions', () => {
+    it('prefers the preview locale when the request falls back to the default locale', () => {
+      const service = getServiceInternals(new ContentService())
+
+      const options = service.createContentOptions({
+        contentType: 'landingPage',
+        locale: 'en-US',
+        previewData: {
+          contentType: 'landingPage',
+          documentId: 'entry-1',
+          versionId: 'branch-1',
+          locale: 'pt-BR',
+        },
+      })
+
+      expect(options.locale).toBe('pt-BR')
+    })
+
+    it('keeps the explicit route locale when it already differs from the default locale', () => {
+      const service = getServiceInternals(new ContentService())
+
+      const options = service.createContentOptions({
+        contentType: 'landingPage',
+        locale: 'fr-FR',
+        previewData: {
+          contentType: 'landingPage',
+          documentId: 'entry-1',
+          versionId: 'branch-1',
+          locale: 'pt-BR',
+        },
+      })
+
+      expect(options.locale).toBe('fr-FR')
+    })
+
+    it('does not leak the preview locale into CMS locator params', () => {
+      const service = getServiceInternals(new ContentService())
+
+      const options = service.createContentOptions({
+        contentType: 'landingPage',
+        locale: 'en-US',
+        previewData: {
+          contentType: 'landingPage',
+          documentId: 'entry-1',
+          versionId: 'branch-1',
+          locale: 'pt-BR',
+        },
+      })
+
+      expect('locale' in options.cmsOptions).toBe(false)
+    })
+  })
+})

package/test/server/index.test.ts

@@ -1,11 +1,8 @@
 import { assertValidSchema } from 'graphql'
+import { describe, expect, it } from 'vitest'
 
 import storeConfig from '../../discovery.config'
-import { execute, getEnvelop } from '../../src/server'
-import {
-  getMergedSchema,
-  getTypeDefsFromFolder,
-} from '../../src/server/generator/schema'
+import { execute, getEnvelop, getFinalAPISchema } from '../../src/server'
 
 const TYPES = [
   'StoreAggregateOffer',
@@ -83,6 +80,8 @@ const QUERIES = [
   'pickupPoints',
 ]
 
+const OPTIONAL_GENERATED_QUERIES = new Set(['accountName'])
+
 const MUTATIONS = [
   'validateCart',
   'validateSession',
@@ -93,7 +92,7 @@ const MUTATIONS = [
 
 describe('FastStore GraphQL Layer', () => {
   describe('@faststore/api', () => {
-    const nativeSchema = getMergedSchema()
+    const nativeSchema = getFinalAPISchema()
 
     it('should return a valid GraphQL schema', async () => {
       // `assertValidSchema()` will throw an error if the schema is invalid, and
@@ -109,8 +108,11 @@ describe('FastStore GraphQL Layer', () => {
 
     it('should return a valid GraphQL schema contain all expected queries', async () => {
       const queryFields = nativeSchema.getQueryType()?.getFields() ?? {}
+      const queryNames = Object.keys(queryFields).filter(
+        (query) => !OPTIONAL_GENERATED_QUERIES.has(query)
+      )
 
-      expect(Object.keys(queryFields)).toEqual(QUERIES)
+      expect(queryNames).toEqual(QUERIES)
     })
 
     it('should return a valid GraphQL schema contain all expected mutations', async () => {
@@ -120,23 +122,9 @@ describe('FastStore GraphQL Layer', () => {
     })
   })
 
-  describe('VTEX API Extension', () => {
-    it('getTypeDefsFromFolder function should return an Array', () => {
-      const typeDefs = getTypeDefsFromFolder('vtex')
-      expect(typeDefs).toBeInstanceOf(Array)
-    })
-  })
-
-  describe('Third Party API Extension', () => {
-    it('getTypeDefsFromFolder function should return an Array', () => {
-      const typeDefs = getTypeDefsFromFolder('thirdParty')
-      expect(typeDefs).toBeInstanceOf(Array)
-    })
-  })
-
   describe('Final Schema after merging', () => {
     it('should return a valid merged GraphQL schema', async () => {
-      const schema = getMergedSchema()
+      const schema = getFinalAPISchema()
 
       // `assertValidSchema()` will throw an error if the schema is invalid, and
       // return nothing if it is valid. That's why we're checking for `undefined`.

package/test/utils/cookieCacheBusting.test.ts

@@ -1,26 +1,34 @@
 /**
- * @jest-environment jsdom
+ * @vitest-environment jsdom
  */
 
-const mockRead = jest.fn()
-const mockReadInitial = jest.fn()
+import { beforeEach, describe, expect, it, vi } from 'vitest'
 
-jest.mock('src/sdk/session', () => ({
-  sessionStore: {
-    read: () => mockRead(),
-    readInitial: () => mockReadInitial(),
+const mockRead = vi.fn()
+const mockReadInitial = vi.fn()
+
+vi.mock('discovery.config', () => ({
+  __esModule: true,
+  default: {
+    api: {
+      storeId: 'store',
+    },
+    deliveryPromise: { enabled: true },
   },
 }))
 
-jest.mock('discovery.config', () => ({
-  deliveryPromise: { enabled: true },
+vi.mock('src/sdk/session', () => ({
+  sessionStore: {
+    read: (...args: unknown[]) => mockRead(...args),
+    readInitial: (...args: unknown[]) => mockReadInitial(...args),
+  },
 }))
 
 import {
   getClientCacheBustingValue,
+  STORAGE_KEY_CACHE_BUST_LAST_VALUE,
   STORAGE_KEY_PERSON_ID,
   STORAGE_KEY_POSTAL_CODE,
-  STORAGE_KEY_CACHE_BUST_LAST_VALUE,
 } from '../../src/utils/cookieCacheBusting'
 
 const setSession = ({
@@ -45,14 +53,14 @@ const clearSession = () => {
 
 describe('cookieCacheBusting', () => {
   beforeEach(() => {
-    jest.restoreAllMocks()
     sessionStorage.clear()
+    vi.restoreAllMocks()
     clearSession()
   })
 
   describe('returns null (shared public CDN cache)', () => {
     it('should clear storage and return null when neither person nor postalCode is set', () => {
-      const removeItemSpy = jest.spyOn(Storage.prototype, 'removeItem')
+      const removeItemSpy = vi.spyOn(Storage.prototype, 'removeItem')
 
       const result = getClientCacheBustingValue()
 
@@ -69,8 +77,8 @@ describe('cookieCacheBusting', () => {
     it('should return a new timestamp value and persist when person logs in', () => {
       setSession({ personId: 'user-id-1' })
 
-      const nowSpy = jest.spyOn(Date, 'now').mockReturnValue(1700000000000)
-      const setItemSpy = jest.spyOn(Storage.prototype, 'setItem')
+      const nowSpy = vi.spyOn(Date, 'now').mockReturnValue(1700000000000)
+      const setItemSpy = vi.spyOn(Storage.prototype, 'setItem')
 
       const result = getClientCacheBustingValue()
 
@@ -94,8 +102,8 @@ describe('cookieCacheBusting', () => {
         '1700000000000::user-id-1'
       )
 
-      const nowSpy = jest.spyOn(Date, 'now')
-      const setItemSpy = jest.spyOn(Storage.prototype, 'setItem')
+      const nowSpy = vi.spyOn(Date, 'now')
+      const setItemSpy = vi.spyOn(Storage.prototype, 'setItem')
 
       const result = getClientCacheBustingValue()
 
@@ -108,8 +116,8 @@ describe('cookieCacheBusting', () => {
       setSession({ personId: 'user-id-1' })
       sessionStorage.setItem(STORAGE_KEY_PERSON_ID, 'user-id-1')
 
-      const nowSpy = jest.spyOn(Date, 'now').mockReturnValue(1700000000123)
-      const setItemSpy = jest.spyOn(Storage.prototype, 'setItem')
+      const nowSpy = vi.spyOn(Date, 'now').mockReturnValue(1700000000123)
+      const setItemSpy = vi.spyOn(Storage.prototype, 'setItem')
 
       const result = getClientCacheBustingValue()
 
@@ -133,7 +141,7 @@ describe('cookieCacheBusting', () => {
         '1700000000000::user-id-1'
       )
 
-      jest.spyOn(Date, 'now').mockReturnValue(1700000000456)
+      vi.spyOn(Date, 'now').mockReturnValue(1700000000456)
 
       const result = getClientCacheBustingValue()
 
@@ -149,7 +157,7 @@ describe('cookieCacheBusting', () => {
     it('should return a value for anonymous users who have a postalCode set', () => {
       setSession({ postalCode: '24230220' })
 
-      jest.spyOn(Date, 'now').mockReturnValue(1700000001000)
+      vi.spyOn(Date, 'now').mockReturnValue(1700000001000)
 
       const result = getClientCacheBustingValue()
 
@@ -164,7 +172,7 @@ describe('cookieCacheBusting', () => {
         '1700000001000::24230220'
       )
 
-      const nowSpy = jest.spyOn(Date, 'now')
+      const nowSpy = vi.spyOn(Date, 'now')
 
       const result = getClientCacheBustingValue()
 
@@ -180,7 +188,7 @@ describe('cookieCacheBusting', () => {
         '1700000001000::50030260'
       )
 
-      jest.spyOn(Date, 'now').mockReturnValue(1700000002000)
+      vi.spyOn(Date, 'now').mockReturnValue(1700000002000)
 
       const result = getClientCacheBustingValue()
 
@@ -194,7 +202,7 @@ describe('cookieCacheBusting', () => {
     it('should combine personId and postalCode for logged-in users', () => {
       setSession({ personId: 'user-id-1', postalCode: '24230220' })
 
-      jest.spyOn(Date, 'now').mockReturnValue(1700000003000)
+      vi.spyOn(Date, 'now').mockReturnValue(1700000003000)
 
       const result = getClientCacheBustingValue()
 
@@ -210,7 +218,7 @@ describe('cookieCacheBusting', () => {
         '1700000003000::user-id-1::50030260'
       )
 
-      jest.spyOn(Date, 'now').mockReturnValue(1700000004000)
+      vi.spyOn(Date, 'now').mockReturnValue(1700000004000)
 
       const result = getClientCacheBustingValue()
 

package/test/utils/getRequestHostname.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, it } from 'vitest'
+import { getRequestHostname } from '../../src/utils/getRequestHostname'
+
+describe('getRequestHostname', () => {
+  describe('returns null for missing input', () => {
+    it('returns null when host is null', () => {
+      expect(getRequestHostname(null)).toBeNull()
+    })
+
+    it('returns null when host is undefined', () => {
+      expect(getRequestHostname(undefined)).toBeNull()
+    })
+
+    it('returns null when host is an empty string', () => {
+      expect(getRequestHostname('')).toBeNull()
+    })
+
+    it('returns null when host is whitespace-only', () => {
+      expect(getRequestHostname('   ')).toBeNull()
+    })
+  })
+
+  describe('strips the port', () => {
+    it('removes the port from a hostname with port', () => {
+      expect(getRequestHostname('brandless.fast.store:443')).toBe(
+        'brandless.fast.store'
+      )
+    })
+
+    it('removes the port from localhost', () => {
+      expect(getRequestHostname('localhost:3000')).toBe('localhost')
+    })
+
+    it('keeps the hostname unchanged when there is no port', () => {
+      expect(getRequestHostname('brandless.fast.store')).toBe(
+        'brandless.fast.store'
+      )
+    })
+  })
+
+  describe('lowercases the hostname', () => {
+    it('lowercases an uppercase hostname', () => {
+      expect(getRequestHostname('Brandless.Fast.Store')).toBe(
+        'brandless.fast.store'
+      )
+    })
+
+    it('lowercases a hostname with port', () => {
+      expect(getRequestHostname('STORE.COM:8080')).toBe('store.com')
+    })
+  })
+
+  describe('handles surrounding whitespace', () => {
+    it('trims leading and trailing whitespace', () => {
+      expect(getRequestHostname('  store.com  ')).toBe('store.com')
+    })
+
+    it('trims whitespace and strips port', () => {
+      expect(getRequestHostname('  store.com:443  ')).toBe('store.com')
+    })
+  })
+
+  describe('falls back gracefully on malformed input', () => {
+    it('returns the lowercased pre-port segment when URL parsing fails', () => {
+      // `new URL('https://...')` accepts most strings, so to exercise the
+      // fallback we rely on `.split(':')[0].toLowerCase()` for any value the
+      // URL parser cannot handle. In practice this is a defensive branch.
+      expect(getRequestHostname('STORE.COM:443')).toBe('store.com')
+    })
+  })
+})