@faststore/api 1.5.8 → 1.5.12

package/src/platforms/vtex/loaders/collection.ts

@@ -0,0 +1,50 @@
+import DataLoader from 'dataloader'
+import pLimit from 'p-limit'
+
+import { NotFoundError } from '../utils/errors'
+import type { CollectionPageType } from '../clients/commerce/types/Portal'
+import type { Options } from '..'
+import type { Clients } from '../clients'
+
+// Limits concurrent requests to 20 so that they don't timeout
+const CONCURRENT_REQUESTS_MAX = 20
+
+const collectionPageTypes = new Set([
+  'brand',
+  'category',
+  'department',
+  'subcategory',
+] as const)
+
+export const isCollectionPageType = (x: any): x is CollectionPageType =>
+  typeof x.pageType === 'string' &&
+  collectionPageTypes.has(x.pageType.toLowerCase())
+
+export const getCollectionLoader = (_: Options, clients: Clients) => {
+  const limit = pLimit(CONCURRENT_REQUESTS_MAX)
+
+  const loader = async (
+    slugs: readonly string[]
+  ): Promise<CollectionPageType[]> => {
+    return Promise.all(
+      slugs.map((slug: string) =>
+        limit(async () => {
+          const page = await clients.commerce.catalog.portal.pagetype(slug)
+
+          if (isCollectionPageType(page)) {
+            return page
+          }
+
+          throw new NotFoundError(
+            `Catalog returned ${page.pageType} for slug: ${slug}. This usually happens when there is more than one category with the same name in the same category tree level.`
+          )
+        })
+      )
+    )
+  }
+
+  return new DataLoader<string, CollectionPageType>(loader, {
+    // DataLoader is being used to cache requests, not to batch them
+    batch: false,
+  })
+}

package/src/platforms/vtex/loaders/index.ts

@@ -1,5 +1,6 @@
 import { getSimulationLoader } from './simulation'
 import { getSkuLoader } from './sku'
+import { getCollectionLoader } from './collection'
 import type { Context, Options } from '..'
 
 export type Loaders = ReturnType<typeof getLoaders>
@@ -7,9 +8,11 @@ export type Loaders = ReturnType<typeof getLoaders>
 export const getLoaders = (options: Options, { clients }: Context) => {
   const skuLoader = getSkuLoader(options, clients)
   const simulationLoader = getSimulationLoader(options, clients)
+  const collectionLoader = getCollectionLoader(options, clients)
 
   return {
     skuLoader,
     simulationLoader,
+    collectionLoader,
   }
 }

package/src/platforms/vtex/resolvers/collection.ts

@@ -1,22 +1,20 @@
+import { isCollectionPageType } from '../loaders/collection'
 import { slugify as baseSlugify } from '../utils/slugify'
 import type { Resolver } from '..'
 import type { Brand } from '../clients/commerce/types/Brand'
 import type { CategoryTree } from '../clients/commerce/types/CategoryTree'
-import type { PortalPagetype } from '../clients/commerce/types/Portal'
+import type { CollectionPageType } from '../clients/commerce/types/Portal'
 
-type Root = Brand | (CategoryTree & { level: number }) | PortalPagetype
+type Root = Brand | (CategoryTree & { level: number }) | CollectionPageType
 
 const isBrand = (x: any): x is Brand => x.type === 'brand'
 
-const isPortalPageType = (x: any): x is PortalPagetype =>
-  typeof x.pageType === 'string'
-
 const slugify = (root: Root) => {
   if (isBrand(root)) {
-    return baseSlugify(root.name)
+    return baseSlugify(root.name.toLowerCase())
   }
 
-  if (isPortalPageType(root)) {
+  if (isCollectionPageType(root)) {
     return new URL(`https://${root.url}`).pathname.slice(1)
   }
 
@@ -27,7 +25,7 @@ export const StoreCollection: Record<string, Resolver<Root>> = {
   id: ({ id }) => id.toString(),
   slug: (root) => slugify(root),
   seo: (root) =>
-    isBrand(root) || isPortalPageType(root)
+    isBrand(root) || isCollectionPageType(root)
       ? {
           title: root.title,
           description: root.metaTagDescription,
@@ -39,7 +37,7 @@ export const StoreCollection: Record<string, Resolver<Root>> = {
   type: (root) =>
     isBrand(root)
       ? 'Brand'
-      : isPortalPageType(root)
+      : isCollectionPageType(root)
       ? root.pageType
       : root.level === 0
       ? 'Department'
@@ -51,7 +49,7 @@ export const StoreCollection: Record<string, Resolver<Root>> = {
         }
       : {
           selectedFacets: new URL(
-            isPortalPageType(root) ? `https://${root.url}` : root.url
+            isCollectionPageType(root) ? `https://${root.url}` : root.url
           ).pathname
             .slice(1)
             .split('/')
@@ -62,7 +60,7 @@ export const StoreCollection: Record<string, Resolver<Root>> = {
         },
   breadcrumbList: async (root, _, ctx) => {
     const {
-      clients: { commerce },
+      loaders: { collectionLoader },
     } = ctx
 
     const slug = slugify(root)
@@ -78,17 +76,17 @@ export const StoreCollection: Record<string, Resolver<Root>> = {
       segments.slice(0, index + 1).join('/')
     )
 
-    const pageTypes = await Promise.all(
-      slugs.map((s) => commerce.catalog.portal.pagetype(s))
+    const collections = await Promise.all(
+      slugs.map((s) => collectionLoader.load(s))
     )
 
     return {
-      itemListElement: pageTypes.map((pageType, index) => ({
-        item: new URL(`https://${pageType.url}`).pathname.toLowerCase(),
-        name: pageType.name,
+      itemListElement: collections.map((collection, index) => ({
+        item: new URL(`https://${collection.url}`).pathname.toLowerCase(),
+        name: collection.name,
         position: index + 1,
       })),
-      numberOfItems: pageTypes.length,
+      numberOfItems: collections.length,
     }
   },
 }

package/src/platforms/vtex/resolvers/product.ts

@@ -88,4 +88,9 @@ export const StoreProduct: Record<string, Resolver<Root>> = {
     return { ...simulation, product }
   },
   isVariantOf: ({ isVariantOf }) => isVariantOf,
+  additionalProperty: ({ attributes = [] }) =>
+    attributes.map((attribute) => ({
+      name: attribute.key,
+      value: attribute.value,
+    })),
 }

package/src/platforms/vtex/resolvers/productGroup.ts

@@ -6,4 +6,14 @@ export const StoreProductGroup: Record<string, Resolver<Product>> = {
   hasVariant: (root) => root.skus.map((sku) => enhanceSku(sku, root)),
   productGroupID: ({ product }) => product,
   name: ({ name }) => name,
+  additionalProperty: ({ textAttributes = [], productSpecifications = [] }) => {
+    const specs = new Set(productSpecifications)
+
+    return textAttributes
+      .filter((attribute) => specs.has(attribute.labelKey))
+      .map((attribute) => ({
+        name: attribute.labelKey,
+        value: attribute.labelValue,
+      }))
+  },
 }

package/src/platforms/vtex/resolvers/query.ts

@@ -1,5 +1,4 @@
 import { enhanceSku } from '../utils/enhanceSku'
-import { NotFoundError } from '../utils/errors'
 import { transformSelectedFacet } from '../utils/facets'
 import { SORT_MAP } from '../utils/sort'
 import { StoreCollection } from './collection'
@@ -29,24 +28,12 @@ export const Query = {
 
     return skuLoader.load(locator.map(transformSelectedFacet))
   },
-  collection: async (
-    _: unknown,
-    { slug }: QueryCollectionArgs,
-    ctx: Context
-  ) => {
+  collection: (_: unknown, { slug }: QueryCollectionArgs, ctx: Context) => {
     const {
-      clients: { commerce },
+      loaders: { collectionLoader },
     } = ctx
 
-    const result = await commerce.catalog.portal.pagetype(slug)
-
-    const whitelist = ['Brand', 'Category', 'Department', 'Subcategory']
-
-    if (whitelist.includes(result.pageType)) {
-      return result
-    }
-
-    throw new NotFoundError(`Not Found: ${slug}`)
+    return collectionLoader.load(slug)
   },
   search: async (
     _: unknown,
@@ -100,6 +87,7 @@ export const Query = {
         endCursor: products.total.toString(),
         totalCount: products.total,
       },
+      // after + index is bigger than after+first itself because of the array flat() above
       edges: skus.map((sku, index) => ({
         node: sku,
         cursor: (after + index).toString(),
@@ -140,20 +128,24 @@ export const Query = {
       ...categories,
     ]
 
+    const validCollections = collections
+      // Nullable slugs may cause one route to override the other
+      .filter((node) => Boolean(StoreCollection.slug(node, null, ctx, null)))
+
     return {
       pageInfo: {
-        hasNextPage: false,
-        hasPreviousPage: false,
+        hasNextPage: validCollections.length - after > first,
+        hasPreviousPage: after > 0,
         startCursor: '0',
-        endCursor: '0',
+        endCursor: (
+          Math.min(first, validCollections.length - after) - 1
+        ).toString(),
       },
-      edges: collections
-        // Nullable slugs may cause one route to override the other
-        .filter((node) => Boolean(StoreCollection.slug(node, null, ctx, null)))
-        .slice(after, first)
+      edges: validCollections
+        .slice(after, after + first)
         .map((node, index) => ({
           node,
-          cursor: index.toString(),
+          cursor: (after + index).toString(),
         })),
     }
   },

package/src/typeDefs/index.ts

@@ -20,6 +20,7 @@ import Review from './review.graphql'
 import Seo from './seo.graphql'
 import Cart from './cart.graphql'
 import Status from './status.graphql'
+import PropertyValue from './propertyValue.graphql'
 
 export const typeDefs = [
   Query,
@@ -42,6 +43,7 @@ export const typeDefs = [
   Order,
   Cart,
   Status,
+  PropertyValue,
 ]
   .map(print)
   .join('\n')

package/src/typeDefs/product.graphql

@@ -16,6 +16,7 @@ type StoreProduct {
   review: [StoreReview!]!
   aggregateRating: StoreAggregateRating!
   isVariantOf: StoreProductGroup!
+  additionalProperty: [StorePropertyValue!]!
 }
 
 input IStoreProduct {

package/src/typeDefs/productGroup.graphql

@@ -2,4 +2,5 @@ type StoreProductGroup {
   hasVariant: [StoreProduct!]!
   productGroupID: String!
   name: String!
+  additionalProperty: [StorePropertyValue!]!
 }

package/src/typeDefs/propertyValue.graphql

@@ -0,0 +1,4 @@
+type StorePropertyValue {
+  value: String!
+  name: String!
+}