@faststore/api 1.7.31 → 1.7.34

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

@@ -1,41 +1,23 @@
+import type { Item } from '../clients/search/types/ProductSearchResult'
+import type { StoreProduct } from './product'
+import type { PromiseType } from '../../../typings'
+import type { Resolver } from '..'
 import type { EnhancedSku } from '../utils/enhanceSku'
-import type { Simulation } from '../clients/commerce/types/Simulation'
 
-type Resolvers = (root: Simulation & { product: EnhancedSku }) => unknown
+type Root = PromiseType<ReturnType<typeof StoreProduct.offers>>
 
-const inStock = (item: Simulation['items'][0]) =>
-  item.availability === 'available'
-
-// Smallest Available Selling Price First
-export const sortOfferByPrice = (
-  items: Simulation['items']
-): Simulation['items'] =>
-  items.sort((a, b) => {
-    if (inStock(a) && !inStock(b)) {
-      return -1
-    }
-
-    if (!inStock(a) && inStock(b)) {
-      return 1
-    }
-
-    return a.sellingPrice - b.sellingPrice
-  })
-
-export const StoreAggregateOffer: Record<string, Resolvers> = {
-  highPrice: ({ items }) => {
-    const availableItems = items.filter(inStock)
-    const highPrice = availableItems.pop()?.sellingPrice
-
-    return (highPrice ?? 0) / 1e2
-  },
-  lowPrice: ({ items }) => {
-    const availableItems = items.filter(inStock)
-    const lowPrice = availableItems[0]?.sellingPrice
-
-    return (lowPrice ?? 0) / 1e2
-  },
+export const StoreAggregateOffer: Record<string, Resolver<Root>> & {
+  offers: Resolver<Root, any, Array<Item & { product: EnhancedSku }>>
+} = {
+  highPrice: ({ product }) =>
+    product.isVariantOf.priceRange.sellingPrice.highPrice ?? 0,
+  lowPrice: (root) =>
+    root.product.isVariantOf.priceRange.sellingPrice.lowPrice ?? 0,
   offerCount: ({ items }) => items.length,
   priceCurrency: () => '',
-  offers: ({ items, product }) => items.map((item) => ({ ...item, product })),
+  offers: ({ items, product }) =>
+    items.map((item) => ({
+      ...item,
+      product,
+    })),
 }

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

@@ -1,11 +1,11 @@
 import type { Resolver } from '..'
-import type { Attribute } from '../clients/search/types/AttributeSearchResult'
+import type { Facet } from '../clients/search/types/FacetSearchResult'
 
-type Root = Attribute
+type Root = Facet
 
 export const StoreFacet: Record<string, Resolver<Root>> = {
-  key: ({ key }) => key,
-  label: ({ label }) => label,
+  key: ({ key }) => key ?? '',
+  label: ({ name }) => name ?? 'unknown',
   values: ({ values }) => values,
-  type: ({ type }) => (type === 'text' ? 'BOOLEAN' : 'RANGE'),
+  type: ({ type }) => (type === 'TEXT' ? 'BOOLEAN' : 'RANGE'),
 }

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

@@ -1,11 +1,12 @@
 import type { Resolver } from '..'
-import type { Value } from '../clients/search/types/AttributeSearchResult'
+import type { FacetValue } from '../clients/search/types/FacetSearchResult'
 
-type Root = Value
+type Root = FacetValue
 
 export const StoreFacetValue: Record<string, Resolver<Root>> = {
-  value: ({ key, from, to }) => key ?? `${from}-to-${to}`,
-  label: ({ label }) => label ?? 'unknown',
-  selected: ({ active }) => active,
-  quantity: ({ count }) => count,
+  value: ({ value, range }) =>
+    value ?? `${range?.from ?? ''}-to-${range?.to ?? ''}`,
+  label: ({ name }) => name || 'unknown',
+  selected: ({ selected }) => selected,
+  quantity: ({ quantity }) => quantity,
 }

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

@@ -1,26 +1,116 @@
-import type { EnhancedSku } from '../utils/enhanceSku'
 import type { Resolver } from '..'
-import type { Item } from '../clients/commerce/types/Simulation'
+import type { StoreAggregateOffer } from './aggregateOffer'
+import {
+  getFirstSeller,
+  inStock,
+  inStockOrderFormItem,
+} from '../utils/productStock'
+import { getItemPriceByKey } from '../utils/price'
+import type { ArrayElementType } from '../../../typings'
+import type { Item } from '../clients/search/types/ProductSearchResult'
+import type { EnhancedSku } from '../utils/enhanceSku'
 import type { OrderFormItem } from '../clients/commerce/types/OrderForm'
 
-type Root =
-  | (Item & { product: EnhancedSku }) // when querying search/product
-  | (OrderFormItem & { product: Promise<EnhancedSku> }) // when querying order
+type OrderFormProduct = OrderFormItem & { product: Promise<EnhancedSku> }
+type SearchProduct = ArrayElementType<
+  ReturnType<typeof StoreAggregateOffer.offers>
+>
+type Root = SearchProduct | OrderFormProduct
+
+const isSearchItem = (item: any): item is Item => 'sellers' in item
+const isOrderFormItem = (item: any): item is OrderFormProduct =>
+  'skuName' in item
+
+const getAvailability = (available: boolean) =>
+  available ? 'https://schema.org/InStock' : 'https://schema.org/OutOfStock'
 
 export const StoreOffer: Record<string, Resolver<Root>> = {
   priceCurrency: () => '',
-  priceValidUntil: ({ priceValidUntil }) => priceValidUntil ?? '',
+  priceValidUntil: (item) => {
+    if (isSearchItem(item)) {
+      return getFirstSeller(item.sellers)?.commertialOffer.PriceValidUntil ?? ''
+    }
+
+    if (isOrderFormItem(item)) {
+      return item.priceValidUntil ?? ''
+    }
+
+    return null
+  },
   itemCondition: () => 'https://schema.org/NewCondition',
-  availability: ({ availability }) =>
-    availability === 'available'
-      ? 'https://schema.org/InStock'
-      : 'https://schema.org/OutOfStock',
-  seller: ({ seller }) => ({
-    identifier: seller,
-  }),
-  price: ({ sellingPrice }) => sellingPrice / 1e2, // TODO add spot price calculation
-  sellingPrice: ({ sellingPrice }) => sellingPrice / 1e2,
-  listPrice: ({ listPrice }) => listPrice / 1e2,
+  availability: async (item) => {
+    if (isSearchItem(item)) {
+      return getAvailability(!!inStock(item))
+    }
+
+    if (isOrderFormItem(item)) {
+      return getAvailability(inStockOrderFormItem(item.availability))
+    }
+
+    return null
+  },
+  seller: (item) => {
+    if (isSearchItem(item)) {
+      return {
+        identifier: getFirstSeller(item.sellers)?.sellerId ?? '',
+      }
+    }
+
+    if (isOrderFormItem(item)) {
+      return {
+        identifier: item.seller,
+      }
+    }
+
+    return null
+  },
+  price: (item) => {
+    if (isSearchItem(item)) {
+      return getItemPriceByKey(item, 'spotPrice')
+    }
+
+    if (isOrderFormItem(item)) {
+      return item.price / 1e2
+    }
+
+    return null
+  },
+  sellingPrice: (item) => {
+    if (isSearchItem(item)) {
+      return getItemPriceByKey(item, 'Price')
+    }
+
+    if (isOrderFormItem(item)) {
+      return item.sellingPrice / 1e2
+    }
+
+    return null
+  },
+  listPrice: (item) => {
+    if (isSearchItem(item)) {
+      return getItemPriceByKey(item, 'ListPrice')
+    }
+
+    if (isOrderFormItem(item)) {
+      return item.listPrice / 1e2
+    }
+
+    return null
+  },
   itemOffered: ({ product }) => product,
-  quantity: ({ quantity }) => quantity,
+  quantity: (item) => {
+    if (isSearchItem(item)) {
+      return item.sellers.reduce(
+        (quantity, seller) =>
+          quantity + seller.commertialOffer.AvailableQuantity,
+        0
+      )
+    }
+
+    if (isOrderFormItem(item)) {
+      return item.quantity
+    }
+
+    return null
+  },
 }

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

@@ -1,13 +1,15 @@
-import { slugify } from '../utils/slugify'
 import type { Resolver } from '..'
+import { sortOfferByPrice } from '../utils/productStock'
+import type { PromiseType } from '../../../typings'
+import type { Query } from './query'
+import type { Item } from '../clients/search/types/ProductSearchResult'
 import type { EnhancedSku } from '../utils/enhanceSku'
-import { sortOfferByPrice } from './aggregateOffer'
 
-type Root = EnhancedSku
+type Root = PromiseType<ReturnType<typeof Query.product>>
 
 const DEFAULT_IMAGE = {
-  name: 'image',
-  value:
+  imageText: 'image',
+  imageUrl:
     'https://storecomponents.vtexassets.com/assets/faststore/images/image___117a6d3e229a96ad0e0d0876352566e2.svg',
 }
 
@@ -16,84 +18,64 @@ const getPath = (link: string, id: string) => `/${getSlug(link, id)}/p`
 const nonEmptyArray = <T>(array: T[] | null | undefined) =>
   Array.isArray(array) && array.length > 0 ? array : null
 
-export const StoreProduct: Record<string, Resolver<Root>> = {
-  productID: ({ id }) => id,
-  name: ({ isVariantOf, name }) => name ?? isVariantOf.name,
-  slug: ({ isVariantOf: { link }, id }) => getSlug(link, id),
+export const StoreProduct: Record<string, Resolver<Root>> & {
+  offers: Resolver<Root, any, { items: Item[]; product: EnhancedSku }>
+  isVariantOf: Resolver<Root, any, Root>
+} = {
+  productID: ({ itemId }) => itemId,
+  name: ({ isVariantOf, name }) => name ?? isVariantOf.productName,
+  slug: ({ isVariantOf: { linkText }, itemId }) => getSlug(linkText, itemId),
   description: ({ isVariantOf: { description } }) => description,
-  seo: ({ isVariantOf: { name, description } }) => ({
-    title: name,
+  seo: ({ isVariantOf: { description, productName } }) => ({
+    title: productName,
     description,
   }),
   brand: ({ isVariantOf: { brand } }) => ({ name: brand }),
-  breadcrumbList: ({ isVariantOf: { categoryTrees, name, link }, id }) => ({
-    itemListElement: [
-      ...categoryTrees.reverse().map(({ categoryNames }, index) => ({
-        name: categoryNames[categoryNames.length - 1],
-        item: `/${categoryNames
-          .map((categoryName) => slugify(categoryName))
-          .join('/')}`,
-        position: index + 1,
-      })),
-      {
-        name,
-        item: getPath(link, id),
-        position: categoryTrees.length + 1,
-      },
-    ],
-    numberOfItems: categoryTrees.length,
-  }),
-  image: ({ isVariantOf, images }) =>
-    (
-      nonEmptyArray(images) ??
-      nonEmptyArray(isVariantOf.images) ?? [DEFAULT_IMAGE]
-    ).map(({ name, value }) => ({
-      alternateName: name ?? '',
-      url: value.replace('vteximg.com.br', 'vtexassets.com'),
-    })),
-  sku: ({ id }) => id,
-  gtin: ({ reference }) => reference ?? '',
-  review: () => [],
-  aggregateRating: () => ({}),
-  offers: async (product, _, ctx) => {
-    const {
-      loaders: { simulationLoader },
-      storage: { channel },
-    } = ctx
-
-    const { id, policies } = product
-
-    const sellers = policies.find(
-      (policy) => policy.id === channel.salesChannel
-    )?.sellers
+  breadcrumbList: ({
+    isVariantOf: { categories, productName, linkText },
+    itemId,
+  }) => {
+    return {
+      itemListElement: [
+        ...categories.reverse().map((categoryPath, index) => {
+          const categoryNames = categoryPath.split('/')
 
-    if (sellers === null || sellers === undefined) {
-      // This error will likely happen when you forget to forward the channel somewhere in your code.
-      // Make sure all queries that lead to a product are forwarding the channel in context corectly
-      throw new Error(
-        `Product with id ${id} has no sellers for sales channel ${channel.salesChannel}.`
-      )
+          return {
+            name: categoryNames[categoryNames.length - 2],
+            item: categoryPath.toLowerCase(),
+            position: index + 1,
+          }
+        }),
+        {
+          name: productName,
+          item: getPath(linkText, itemId),
+          position: categories.length + 1,
+        },
+      ],
+      numberOfItems: categories.length,
     }
-
-    // Unique seller ids
-    const sellerIds = sellers.map((seller) => seller.id)
-    const items = Array.from(new Set(sellerIds)).map((seller) => ({
-      quantity: 1,
-      seller,
-      id,
-    }))
-
-    const simulation = await simulationLoader.load(items)
-
+  },
+  image: ({ images }) =>
+    (nonEmptyArray(images) ?? [DEFAULT_IMAGE]).map(
+      ({ imageUrl, imageText }) => ({
+        alternateName: imageText ?? '',
+        url: imageUrl.replace('vteximg.com.br', 'vtexassets.com'),
+      })
+    ),
+  sku: ({ itemId }) => itemId,
+  gtin: ({ referenceId }) => referenceId[0]?.Value ?? '',
+  review: () => [],
+  aggregateRating: () => ({}),
+  offers: (product): { items: Item[]; product: Root } => {
     return {
-      ...simulation,
-      items: sortOfferByPrice(simulation.items),
+      items: sortOfferByPrice(product.isVariantOf.items),
       product,
     }
   },
-  isVariantOf: ({ isVariantOf }) => isVariantOf,
-  additionalProperty: ({ attributes = [] }) =>
-    attributes.map((attribute) => ({
+  isVariantOf: (root) => root,
+  // TODO: get this value. Fix any type
+  additionalProperty: ({ attributes = [] }: any) =>
+    attributes.map((attribute: any) => ({
       name: attribute.key,
       value: attribute.value,
     })),

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

@@ -1,19 +1,28 @@
 import { enhanceSku } from '../utils/enhanceSku'
-import type { Product } from '../clients/search/types/ProductSearchResult'
 import type { Resolver } from '..'
+import type { PromiseType } from '../../../typings'
+import type { StoreProduct } from './product'
 
-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)
+type Root = PromiseType<ReturnType<typeof StoreProduct.isVariantOf>>
 
-    return textAttributes
-      .filter((attribute) => specs.has(attribute.labelKey))
-      .map((attribute) => ({
-        name: attribute.labelKey,
-        value: attribute.labelValue,
+const BLOCKED_PROPERTIES: Record<string, boolean> = {
+  sellerId: true,
+}
+
+export const StoreProductGroup: Record<string, Resolver<Root>> = {
+  hasVariant: (root) =>
+    root.isVariantOf.items.map((item) => enhanceSku(item, root.isVariantOf)),
+  productGroupID: ({ isVariantOf }) => isVariantOf.productId,
+  name: ({ isVariantOf }) => isVariantOf.productName,
+  additionalProperty: ({ isVariantOf: { properties } }) =>
+    properties.flatMap((property) => {
+      if (BLOCKED_PROPERTIES[property.name]) {
+        return []
+      }
+
+      return property.values.map((propertyValue) => ({
+        name: property.name,
+        value: propertyValue,
       }))
-  },
+    }),
 }

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

@@ -77,7 +77,7 @@ export const Query = {
     })
 
     const skus = products.products
-      .map((product) => product.skus.map((sku) => enhanceSku(sku, product)))
+      .map((product) => product.items.map((sku) => enhanceSku(sku, product)))
       .flat()
       .filter((sku) => sku.sellers.length > 0)
 
@@ -86,8 +86,8 @@ export const Query = {
         hasNextPage: products.pagination.after.length > 0,
         hasPreviousPage: products.pagination.before.length > 0,
         startCursor: '0',
-        endCursor: products.total.toString(),
-        totalCount: products.total,
+        endCursor: products.recordsFiltered.toString(),
+        totalCount: products.recordsFiltered,
       },
       // after + index is bigger than after+first itself because of the array flat() above
       edges: skus.map((sku, index) => ({

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

@@ -1,23 +1,35 @@
 import { enhanceSku } from '../utils/enhanceSku'
 import type { Resolver } from '..'
 import type { SearchArgs } from '../clients/search'
-import type { Attribute } from '../clients/search/types/AttributeSearchResult'
+import type { Facet } from '../clients/search/types/FacetSearchResult'
 
 type Root = Omit<SearchArgs, 'type'>
 
-const REMOVED_FACETS_FROM_COLLECTION_PAGE = ['departamento']
+const REMOVED_FACETS_FROM_COLLECTION_PAGE = ['departamento', 'Departamento']
 
 export const StoreSearchResult: Record<string, Resolver<Root>> = {
   products: async (searchArgs, _, ctx) => {
     const {
-      clients: { search },
+      clients: { search, sp },
     } = ctx
 
     const products = await search.products(searchArgs)
 
+    // Raise event on search's analytics API when performing
+    // a full text search.
+    if (searchArgs.query) {
+      sp.sendEvent({
+        type: 'search.query',
+        text: searchArgs.query,
+        misspelled: products.correction.misspelled,
+        match: products.recordsFiltered,
+        operator: products.operator,
+      }).catch(console.error)
+    }
+
     const skus = products.products
       .map((product) => {
-        const [maybeSku] = product.skus
+        const [maybeSku] = product.items
 
         return maybeSku && enhanceSku(maybeSku, product)
       })
@@ -28,8 +40,8 @@ export const StoreSearchResult: Record<string, Resolver<Root>> = {
         hasNextPage: products.pagination.after.length > 0,
         hasPreviousPage: products.pagination.before.length > 0,
         startCursor: '0',
-        endCursor: products.total.toString(),
-        totalCount: products.total,
+        endCursor: products.recordsFiltered.toString(),
+        totalCount: products.recordsFiltered,
       },
       edges: skus.map((sku, index) => ({
         node: sku,
@@ -42,12 +54,12 @@ export const StoreSearchResult: Record<string, Resolver<Root>> = {
       clients: { search: is },
     } = ctx
 
-    const facets = await is.facets(searchArgs)
+    const { facets } = await is.facets(searchArgs)
 
     const isCollectionPage = !searchArgs.query
-    const filteredFacets = facets?.attributes?.reduce((acc, currentFacet) => {
+    const filteredFacets = facets?.reduce((acc, currentFacet) => {
       const shouldFilterFacet = REMOVED_FACETS_FROM_COLLECTION_PAGE.includes(
-        currentFacet.key
+        currentFacet.name
       )
 
       const shouldRemoveFacetFromCollectionPage =
@@ -58,8 +70,8 @@ export const StoreSearchResult: Record<string, Resolver<Root>> = {
       }
 
       currentFacet.values.sort((a, b) => {
-        const firstItemLabel = a.label ?? ''
-        const secondItemLabel = b.label ?? ''
+        const firstItemLabel = a.name ?? ''
+        const secondItemLabel = b.name ?? ''
 
         return firstItemLabel.localeCompare(secondItemLabel)
       })
@@ -67,7 +79,7 @@ export const StoreSearchResult: Record<string, Resolver<Root>> = {
       acc.push(currentFacet)
 
       return acc
-    }, [] as Attribute[])
+    }, [] as Facet[])
 
     return filteredFacets ?? []
   },

package/src/platforms/vtex/utils/enhanceSku.ts

@@ -1,8 +1,8 @@
-import type { Product, Sku } from '../clients/search/types/ProductSearchResult'
+import type { Product, Item } from '../clients/search/types/ProductSearchResult'
 
-export type EnhancedSku = Sku & { isVariantOf: Product }
+export type EnhancedSku = Item & { isVariantOf: Product }
 
-export const enhanceSku = (sku: Sku, product: Product): EnhancedSku => ({
-  ...sku,
+export const enhanceSku = (item: Item, product: Product): EnhancedSku => ({
+  ...item,
   isVariantOf: product,
 })

package/src/platforms/vtex/utils/facets.ts

@@ -13,9 +13,15 @@ export const transformSelectedFacet = ({ key, value }: SelectedFacet) => {
   switch (key) {
     case 'channel': {
       const channel = ChannelMarshal.parse(value)
+      const channelFacets = [
+        { key: 'trade-policy', value: channel.salesChannel },
+      ]
 
-      // This array should have all values from channel string
-      return [{ key: 'trade-policy', value: channel.salesChannel }]
+      if (channel.regionId) {
+        channelFacets.push({ key: 'region-id', value: channel.regionId })
+      }
+
+      return channelFacets
     }
 
     default:

package/src/platforms/vtex/utils/price.ts

@@ -0,0 +1,10 @@
+import type {
+  CommertialOffer,
+  Item,
+} from '../clients/search/types/ProductSearchResult'
+import { getFirstSeller } from './productStock'
+
+export const getItemPriceByKey = (
+  item: Item,
+  key: keyof CommertialOffer
+): number => getFirstSeller(item.sellers)?.commertialOffer[key] ?? 0

package/src/platforms/vtex/utils/productStock.ts

@@ -0,0 +1,25 @@
+import type { Item, Seller } from '../clients/search/types/ProductSearchResult'
+import { getItemPriceByKey } from './price'
+
+export const inStock = (item: Item) =>
+  item.sellers.find((seller) => seller.commertialOffer.AvailableQuantity > 0)
+
+export const getFirstSeller = (sellers: Seller[]): Seller | undefined =>
+  sellers[0]
+
+// Smallest Available Selling Price First
+export const sortOfferByPrice = (items: Item[]): Item[] =>
+  items.sort((a, b) => {
+    if (inStock(a) && !inStock(b)) {
+      return -1
+    }
+
+    if (!inStock(a) && inStock(b)) {
+      return 1
+    }
+
+    return getItemPriceByKey(a, 'Price') - getItemPriceByKey(b, 'Price')
+  })
+
+export const inStockOrderFormItem = (availability: string) =>
+  availability === 'available'

package/src/typings/index.ts

@@ -1 +1,5 @@
 export type Platform = 'vtex'
+
+export type PromiseType<T> = T extends Promise<infer U> ? U : T
+
+export type ArrayElementType<T> = T extends Array<infer U> ? U : T