@faststore/api 1.7.50 → 1.7.53

package/src/platforms/vtex/clients/search/index.ts

@@ -5,7 +5,7 @@ import { fetchAPI } from '../fetch'
 import type { FacetSearchResult } from './types/FacetSearchResult'
 import type {
   ProductSearchResult,
-  SuggestedTerms,
+  Suggestion,
 } from './types/ProductSearchResult'
 
 export type Sort =
@@ -90,12 +90,16 @@ export const IntelligentSearch = (
   const suggestedProducts = (
     args: Omit<SearchArgs, 'type'>
   ): Promise<ProductSearchResult> =>
-    fetchAPI(`${base}/api/suggestion_products/?term=${args.query}`)
+    fetchAPI(
+      `${base}/_v/api/intelligent-search/product_search?query=${args.query}`
+    )
 
   const suggestedTerms = (
     args: Omit<SearchArgs, 'type'>
-  ): Promise<SuggestedTerms> =>
-    fetchAPI(`${base}/api/split/suggestion_search/?q=${args.query}`)
+  ): Promise<Suggestion> =>
+    fetchAPI(
+      `${base}/_v/api/intelligent-search/search_suggestions?query=${args.query}`
+    )
 
   const facets = (args: Omit<SearchArgs, 'type'>) =>
     search<FacetSearchResult>({ ...args, type: 'facets' })

package/src/platforms/vtex/clients/search/types/ProductSearchResult.ts

@@ -57,17 +57,6 @@ export interface First {
   index: number
 }
 
-export interface SuggestedTerms {
-  total: number
-  sampling: boolean
-  translated: boolean
-  locale: string
-  query: string
-  operator: string
-  suggestion: Suggestion
-  correction: Correction
-}
-
 export interface Suggestion {
   searches: Search[]
 }
@@ -98,7 +87,7 @@ export interface Product {
   items: Item[]
   skuSpecifications?: SkuSpecification[]
   priceRange: PriceRange
-  specificationGroups: SpecificationGroup
+  specificationGroups: SpecificationGroup[]
   properties: Array<{ name: string; values: string[] }>
   selectedProperties: Array<{ key: string; value: string }>
 }
@@ -133,7 +122,10 @@ export interface Item {
   modalType: any | null
   images: Image[]
   Videos: string[]
-  variations: string[]
+  variations: Array<{
+    name: string
+    values: string[]
+  }>
   sellers: Seller[]
   attachments: Array<{
     id: number
@@ -214,5 +206,9 @@ interface PriceRange {
 interface SpecificationGroup {
   name: string
   originalName: string
-  specifications: { name: string; originalName: string; values: string[] }
+  specifications: Array<{
+    name: string
+    originalName: string
+    values: string[]
+  }>
 }

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

@@ -73,10 +73,9 @@ export const StoreProduct: Record<string, Resolver<Root>> & {
     }
   },
   isVariantOf: (root) => root,
-  // TODO: get this value. Fix any type
-  additionalProperty: ({ attributes = [] }: any) =>
-    attributes.map((attribute: any) => ({
-      name: attribute.key,
-      value: attribute.value,
-    })),
+  additionalProperty: ({ variations = [] }) => {
+    return variations.flatMap(({ name, values }) =>
+      values.map((value) => ({ name, value }))
+    )
+  },
 }

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

@@ -5,24 +5,24 @@ import type { StoreProduct } from './product'
 
 type Root = PromiseType<ReturnType<typeof StoreProduct.isVariantOf>>
 
-const BLOCKED_PROPERTIES: Record<string, boolean> = {
-  sellerId: true,
-}
+const BLOCKED_SPECIFICATIONS = new Set(['allSpecifications'])
 
 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,
-      }))
-    }),
+  additionalProperty: ({ isVariantOf: { specificationGroups } }) =>
+    specificationGroups
+      // filter sku specifications so we dont mess sku with product specs
+      .filter(
+        (specificationGroup) =>
+          !BLOCKED_SPECIFICATIONS.has(specificationGroup.name)
+      )
+      // Transform specs back into product specs
+      .flatMap(({ specifications }) =>
+        specifications.flatMap(({ name, values }) =>
+          values.map((value) => ({ name, value }))
+        )
+      ),
 }

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

@@ -24,9 +24,7 @@ export const StoreSearchResult: Record<string, Resolver<Root>> = {
       })
       .filter((sku) => !!sku)
 
-    const {
-      suggestion: { searches },
-    } = terms
+    const { searches } = terms
 
     return {
       terms: searches.map((item) => item.term),