@faststore/core 3.0.56 → 3.0.57

package/.turbo/turbo-build.log

@@ -1,7 +1,7 @@
 $ yarn partytown & yarn generate && next build
+$ faststore generate-graphql -c
 $ partytown copylib ./public/~partytown
 Partytown lib copied to: /home/runner/work/faststore/faststore/packages/core/public/~partytown
-$ faststore generate-graphql -c
 success - GraphQL schema, types, and optimizations successfully generated 🎉
 ⚠ No build cache found. Please configure build caching for faster rebuilds. Read more: https://nextjs.org/docs/messages/no-cache
 Attention: Next.js now collects completely anonymous telemetry regarding usage.
@@ -24,8 +24,8 @@ Browserslist: caniuse-lite is outdated. Please run:
    Collecting page data ...
    Generating static pages (0/9) ...
 
   Generating static pages (2/9) 
-
   Generating static pages (4/9) 
 Warning: Dynamic Content not found for the page: home. Refer to the Dynamic Content documentation at https://developers.vtex.com/docs/guides/faststore/dynamic-content-overview for mapping the page and the corresponding data-fetching function.
+
   Generating static pages (4/9) 
 
   Generating static pages (6/9) 
 
 ✓ Generating static pages (9/9) 
    Finalizing page optimization ...

package/.turbo/turbo-test.log

@@ -1,23 +1,9 @@
 $ jest
-PASS test/server/index.test.ts (26.237 s)
-  FastStore GraphQL Layer
-    @faststore/api
-      ✓ should return a valid GraphQL schema (6 ms)
-      ✓ should return a valid GraphQL schema contain all expected types (7 ms)
-      ✓ should return a valid GraphQL schema contain all expected queries (2 ms)
-      ✓ should return a valid GraphQL schema contain all expected mutations
-    VTEX API Extension
-      ✓ getTypeDefsFromFolder function should return an Array (8 ms)
-    Third Party API Extension
-      ✓ getTypeDefsFromFolder function should return an Array (7 ms)
-    Final Schema after merging
-      ✓ should return a valid merged GraphQL schema (31 ms)
-    Envelop
-      ✓ should exist with its plugins (29 ms)
-      ✓ should handle options and execute (138 ms)
+PASS test/server/cms/index.test.ts (28.834 s)
+PASS test/server/index.test.ts (31.603 s)
 
-Test Suites: 1 passed, 1 total
-Tests:       9 passed, 9 total
+Test Suites: 2 passed, 2 total
+Tests:       12 passed, 12 total
 Snapshots:   0 total
-Time:        26.386 s
+Time:        32.462 s
 Ran all test suites.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@faststore/core",
-  "version": "3.0.56",
+  "version": "3.0.57",
   "license": "MIT",
   "repository": "vtex/faststore",
   "browserslist": "supports es6-module and not dead",
@@ -62,7 +62,7 @@
     "css-loader": "^6.7.1",
     "deepmerge": "^4.3.1",
     "draftjs-to-html": "^0.9.1",
-    "graphql": "^15.0.0",
+    "graphql": "^15.6.0",
     "include-media": "^1.4.10",
     "next": "^13.5.6",
     "next-seo": "^6.4.0",
@@ -125,5 +125,5 @@
     "node": "18.19.0",
     "yarn": "1.19.1"
   },
-  "gitHead": "a066917ae9fe198b270941499ccbd92a401b7423"
+  "gitHead": "b1790641313ddd75103e6697ecfe4adb3f66fef7"
 }

package/src/server/cms/index.ts

@@ -5,6 +5,14 @@ import MissingContentError from 'src/sdk/error/MissingContentError'
 import MultipleContentError from 'src/sdk/error/MultipleContentError'
 import config from '../../../faststore.config'
 
+type Cache<T> = {
+  [key: string]: { data: Array<T> }
+}
+type ExtraOptions = {
+  cmsClient?: ClientCMS
+  cache?: Cache<ContentData>
+}
+
 export type Options =
   | Locator
   | {
@@ -45,10 +53,68 @@ export const clientCMS = new ClientCMS({
   tenant: config.api.storeId,
 })
 
-export const getCMSPage = async (options: Options) => {
-  return await (isLocator(options)
-    ? clientCMS.getCMSPage(options).then((page) => ({ data: [page] }))
-    : clientCMS.getCMSPagesByContentType(options.contentType, options.filters))
+/*
+ * This in memory cache exists because for each page (think category or department)
+ * we are fetching all the pages of the same content type from the headless CMS to
+ * find the one that matches the slug.
+ *
+ * So instead of making multiple request for the Headless CMS API for each page we make
+ * one for each content-type and reuse the results for the next page.
+ *
+ * Since we rebuild on a CMS publication the server will go away and will "invalidate"
+ * the cache
+ */
+const getCMSPageCache = {}
+
+export const getCMSPage = async (
+  options: Options,
+  extraOptions?: ExtraOptions
+) => {
+  const cmsClient = extraOptions?.cmsClient ?? clientCMS
+  const cache = extraOptions?.cache ?? getCMSPageCache
+
+  if (isLocator(options)) {
+    return await cmsClient
+      .getCMSPage(options)
+      .then((page) => ({ data: [page] }))
+  }
+
+  if (!cache[options.contentType]) {
+    const pages = []
+    let page = 1
+    const perPage = 10
+    const response = await cmsClient.getCMSPagesByContentType(
+      options.contentType,
+      { ...options.filters, page: page, perPage }
+    )
+
+    pages.push(...response.data)
+
+    const totalPagesToFetch = Math.ceil(response.totalItems / perPage) // How many pages have content
+    const pagesToFetch = Array.from(
+      { length: totalPagesToFetch - 1 }, // We want all those pages minus the first one that we fetched
+      (_, i) => i + 2 // + 1 because indices are 0 based, and + 1 because we already fetched the first
+    )
+
+    if (response.totalItems > pages.length) {
+      const restOfPages = await Promise.all(
+        pagesToFetch.map((i) =>
+          cmsClient.getCMSPagesByContentType(options.contentType, {
+            ...options.filters,
+            page: i,
+            perPage,
+          })
+        )
+      )
+
+      restOfPages.forEach((response) => {
+        pages.push(...response.data)
+      })
+    }
+    cache[options.contentType] = { data: pages }
+  }
+
+  return cache[options.contentType]
 }
 
 export const getPage = async <T extends ContentData>(options: Options) => {

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

@@ -0,0 +1,95 @@
+import { clientCMS, getCMSPage } from '../../../src/server/cms'
+import { jest } from '@jest/globals'
+import { ContentData } from '@vtex/client-cms'
+
+describe('CMS Integration', () => {
+  const mockData = (count = 1) => {
+    const data: ContentData[] = []
+    for (let i = 0; i < count; i = i + 1) {
+      data.push({
+        id: `data-id-${i}`,
+        name: `data-name-${i}`,
+        status: `data-status-${i}`,
+        type: `data-type-${i}`,
+        sections: [],
+        releaseId: `release-${i}`,
+      })
+    }
+    return data
+  }
+
+  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,
+        })
+      })
+      clientCMS.getCMSPagesByContentType = mockFunction
+
+      const result = await getCMSPage(
+        { contentType: 'plp' },
+        { cmsClient: clientCMS }
+      )
+
+      expect(mockFunction.mock.calls.length).toBe(1)
+      expect(result.data.length).toBe(3)
+    })
+
+    it('loads multiple pages', async () => {
+      const mockFunction: jest.Mock<typeof clientCMS.getCMSPagesByContentType> =
+        jest.fn()
+
+      mockFunction.mockImplementationOnce(() => {
+        return Promise.resolve({
+          data: mockData(10),
+          hasNextPage: true,
+          totalItems: 15,
+        })
+      })
+      mockFunction.mockImplementationOnce(() => {
+        return Promise.resolve({
+          data: mockData(5),
+          hasNextPage: false,
+          totalItems: 15,
+        })
+      })
+
+      clientCMS.getCMSPagesByContentType = mockFunction
+
+      const result = await getCMSPage(
+        { contentType: 'plp' },
+        { cmsClient: clientCMS, cache: {} }
+      )
+
+      expect(mockFunction.mock.calls.length).toBe(2)
+      expect(result.data.length).toBe(15)
+    })
+
+    it('it makes no request if the cache is filled', async () => {
+      const mockFunction: jest.Mock<typeof clientCMS.getCMSPagesByContentType> =
+        jest.fn()
+
+      mockFunction.mockImplementationOnce(() => {
+        return Promise.resolve({
+          data: mockData(10),
+          hasNextPage: true,
+          totalItems: 15,
+        })
+      })
+
+      clientCMS.getCMSPagesByContentType = mockFunction
+
+      const cache = { plp: { data: [] } }
+      const result = await getCMSPage(
+        { contentType: 'plp' },
+        { cmsClient: clientCMS, cache: cache }
+      )
+
+      expect(mockFunction.mock.calls.length).toBe(0)
+      expect(result.data.length).toBe(0)
+    })
+  })
+})