@faststore/api 1.8.2 → 1.8.3

package/dist/platforms/vtex/resolvers/aggregateOffer.d.ts

@@ -1,12 +1,9 @@
-import type { Item } from '../clients/search/types/ProductSearchResult';
+import type { EnhancedCommercialOffer } from '../utils/enhanceCommercialOffer';
 import type { StoreProduct } from './product';
 import type { PromiseType } from '../../../typings';
 import type { Resolver } from '..';
-import type { EnhancedSku } from '../utils/enhanceSku';
 declare type Root = PromiseType<ReturnType<typeof StoreProduct.offers>>;
 export declare const StoreAggregateOffer: Record<string, Resolver<Root>> & {
-    offers: Resolver<Root, any, Array<Item & {
-        product: EnhancedSku;
-    }>>;
+    offers: Resolver<Root, any, EnhancedCommercialOffer[]>;
 };
 export {};

package/dist/platforms/vtex/resolvers/product.d.ts

@@ -1,14 +1,10 @@
+import type { EnhancedCommercialOffer } from '../utils/enhanceCommercialOffer';
 import type { Resolver } from '..';
 import type { PromiseType } from '../../../typings';
 import type { Query } from './query';
-import type { Item } from '../clients/search/types/ProductSearchResult';
-import type { EnhancedSku } from '../utils/enhanceSku';
 declare type Root = PromiseType<ReturnType<typeof Query.product>>;
 export declare const StoreProduct: Record<string, Resolver<Root>> & {
-    offers: Resolver<Root, any, {
-        items: Item[];
-        product: EnhancedSku;
-    }>;
+    offers: Resolver<Root, any, EnhancedCommercialOffer[]>;
     isVariantOf: Resolver<Root, any, Root>;
 };
 export {};

package/dist/platforms/vtex/utils/enhanceCommercialOffer.d.ts

@@ -0,0 +1,7 @@
+import type { CommertialOffer, Seller } from '../clients/search/types/ProductSearchResult';
+import type { EnhancedSku } from './enhanceSku';
+export declare type EnhancedCommercialOffer = CommertialOffer & {
+    seller: Seller;
+    product: EnhancedSku;
+};
+export declare const enhanceCommercialOffer: (offer: CommertialOffer, seller: Seller, product: EnhancedSku) => EnhancedCommercialOffer;

package/dist/platforms/vtex/utils/productStock.d.ts

@@ -1,6 +1,7 @@
-import type { Item, Seller, CommertialOffer } from '../clients/search/types/ProductSearchResult';
-export declare const inStock: (item: Item) => Seller | undefined;
-export declare const getFirstSeller: (sellers: Seller[]) => Seller | undefined;
-export declare const getItemPriceByKey: (item: Item, key: keyof CommertialOffer) => number;
-export declare const sortOfferByPrice: (items: Item[]) => Item[];
-export declare const inStockOrderFormItem: (availability: string) => boolean;
+import type { CommertialOffer } from '../clients/search/types/ProductSearchResult';
+export declare const inStock: (offer: Pick<CommertialOffer, 'AvailableQuantity'>) => boolean;
+export declare const price: (offer: Pick<CommertialOffer, 'spotPrice'>) => number;
+export declare const sellingPrice: (offer: CommertialOffer) => number;
+export declare const availability: (available: boolean) => "https://schema.org/InStock" | "https://schema.org/OutOfStock";
+export declare const bestOfferFirst: (a: Pick<CommertialOffer, 'AvailableQuantity' | 'spotPrice'>, b: Pick<CommertialOffer, 'AvailableQuantity' | 'spotPrice'>) => number;
+export declare const inStockOrderFormItem: (item: string) => boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@faststore/api",
-  "version": "1.8.2",
+  "version": "1.8.3",
   "license": "MIT",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -45,5 +45,5 @@
   "peerDependencies": {
     "graphql": "^15.6.0"
   },
-  "gitHead": "9d777bc857979afa3ebe0a91d0d8653e22821323"
+  "gitHead": "5ef59a54241b14427380079324148b1f69079eca"
 }

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

@@ -154,7 +154,7 @@ export interface CommertialOffer {
   ItemMetadataAttachment: any[]
   Price: number
   ListPrice: number
-  spotPrice?: number
+  spotPrice: number
   PriceWithoutDiscount: number
   RewardValue: number
   PriceValidUntil: string

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

@@ -1,23 +1,25 @@
-import type { Item } from '../clients/search/types/ProductSearchResult'
+import { inStock } from '../utils/productStock'
+import type { EnhancedCommercialOffer } from '../utils/enhanceCommercialOffer'
 import type { StoreProduct } from './product'
 import type { PromiseType } from '../../../typings'
 import type { Resolver } from '..'
-import type { EnhancedSku } from '../utils/enhanceSku'
 
 type Root = PromiseType<ReturnType<typeof StoreProduct.offers>>
 
 export const StoreAggregateOffer: Record<string, Resolver<Root>> & {
-  offers: Resolver<Root, any, Array<Item & { product: EnhancedSku }>>
+  offers: Resolver<Root, any, EnhancedCommercialOffer[]>
 } = {
-  highPrice: ({ product }) =>
-    product.isVariantOf.priceRange.sellingPrice.highPrice ?? 0,
-  lowPrice: (root) =>
-    root.product.isVariantOf.priceRange.sellingPrice.lowPrice ?? 0,
-  offerCount: ({ items }) => items.length,
+  highPrice: (offers) => {
+    const availableOffers = offers.filter(inStock)
+
+    return availableOffers[availableOffers.length - 1]?.Price ?? 0
+  },
+  lowPrice: (offers) => {
+    const availableOffers = offers.filter(inStock)
+
+    return availableOffers[0]?.Price ?? 0
+  },
+  offerCount: (offers) => offers.length,
   priceCurrency: () => '',
-  offers: ({ items, product }) =>
-    items.map((item) => ({
-      ...item,
-      product,
-    })),
+  offers: (offers) => offers,
 }

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

@@ -1,13 +1,13 @@
-import type { Resolver } from '..'
-import type { StoreAggregateOffer } from './aggregateOffer'
 import {
-  getFirstSeller,
+  availability,
   inStock,
   inStockOrderFormItem,
-  getItemPriceByKey,
+  price,
+  sellingPrice,
 } from '../utils/productStock'
+import type { Resolver } from '..'
+import type { StoreAggregateOffer } from './aggregateOffer'
 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'
 
@@ -17,98 +17,93 @@ type SearchProduct = ArrayElementType<
 >
 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 isSearchItem = (item: Root): item is SearchProduct =>
+  'Price' in item && 'seller' in item && 'product' in item
 
-const getAvailability = (available: boolean) =>
-  available ? 'https://schema.org/InStock' : 'https://schema.org/OutOfStock'
+const isOrderFormItem = (item: Root): item is OrderFormProduct =>
+  'skuName' in item
 
 export const StoreOffer: Record<string, Resolver<Root>> = {
   priceCurrency: () => '',
-  priceValidUntil: (item) => {
-    if (isSearchItem(item)) {
-      return getFirstSeller(item.sellers)?.commertialOffer.PriceValidUntil ?? ''
+  priceValidUntil: (root) => {
+    if (isSearchItem(root)) {
+      return root.PriceValidUntil ?? ''
     }
 
-    if (isOrderFormItem(item)) {
-      return item.priceValidUntil ?? ''
+    if (isOrderFormItem(root)) {
+      return root.priceValidUntil ?? ''
     }
 
     return null
   },
   itemCondition: () => 'https://schema.org/NewCondition',
-  availability: async (item) => {
-    if (isSearchItem(item)) {
-      return getAvailability(!!inStock(item))
+  availability: async (root) => {
+    if (isSearchItem(root)) {
+      return availability(inStock(root))
     }
 
-    if (isOrderFormItem(item)) {
-      return getAvailability(inStockOrderFormItem(item.availability))
+    if (isOrderFormItem(root)) {
+      return availability(inStockOrderFormItem(root.availability))
     }
 
     return null
   },
-  seller: (item) => {
-    if (isSearchItem(item)) {
+  seller: (root) => {
+    if (isSearchItem(root)) {
       return {
-        identifier: getFirstSeller(item.sellers)?.sellerId ?? '',
+        identifier: root.seller.sellerId ?? '',
       }
     }
 
-    if (isOrderFormItem(item)) {
+    if (isOrderFormItem(root)) {
       return {
-        identifier: item.seller,
+        identifier: root.seller,
       }
     }
 
     return null
   },
-  price: (item) => {
-    if (isSearchItem(item)) {
-      return getItemPriceByKey(item, 'spotPrice')
+  price: (root) => {
+    if (isSearchItem(root)) {
+      return price(root)
     }
 
-    if (isOrderFormItem(item)) {
-      return item.price / 1e2
+    if (isOrderFormItem(root)) {
+      return root.price / 1e2
     }
 
     return null
   },
-  sellingPrice: (item) => {
-    if (isSearchItem(item)) {
-      return getItemPriceByKey(item, 'Price')
+  sellingPrice: (root) => {
+    if (isSearchItem(root)) {
+      return sellingPrice(root)
     }
 
-    if (isOrderFormItem(item)) {
-      return item.sellingPrice / 1e2
+    if (isOrderFormItem(root)) {
+      return root.sellingPrice / 1e2
     }
 
     return null
   },
-  listPrice: (item) => {
-    if (isSearchItem(item)) {
-      return getItemPriceByKey(item, 'ListPrice')
+  listPrice: (root) => {
+    if (isSearchItem(root)) {
+      return root.ListPrice
     }
 
-    if (isOrderFormItem(item)) {
-      return item.listPrice / 1e2
+    if (isOrderFormItem(root)) {
+      return root.listPrice / 1e2
     }
 
     return null
   },
   itemOffered: ({ product }) => product,
-  quantity: (item) => {
-    if (isSearchItem(item)) {
-      return item.sellers.reduce(
-        (quantity, seller) =>
-          quantity + seller.commertialOffer.AvailableQuantity,
-        0
-      )
+  quantity: (root) => {
+    if (isSearchItem(root)) {
+      return root.AvailableQuantity ?? 0
     }
 
-    if (isOrderFormItem(item)) {
-      return item.quantity
+    if (isOrderFormItem(root)) {
+      return root.quantity
     }
 
     return null

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

@@ -1,9 +1,9 @@
+import { enhanceCommercialOffer } from '../utils/enhanceCommercialOffer'
+import { bestOfferFirst } from '../utils/productStock'
+import type { EnhancedCommercialOffer } from '../utils/enhanceCommercialOffer'
 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'
 
 type Root = PromiseType<ReturnType<typeof Query.product>>
 
@@ -19,7 +19,7 @@ const nonEmptyArray = <T>(array: T[] | null | undefined) =>
   Array.isArray(array) && array.length > 0 ? array : null
 
 export const StoreProduct: Record<string, Resolver<Root>> & {
-  offers: Resolver<Root, any, { items: Item[]; product: EnhancedSku }>
+  offers: Resolver<Root, any, EnhancedCommercialOffer[]>
   isVariantOf: Resolver<Root, any, Root>
 } = {
   productID: ({ itemId }) => itemId,
@@ -66,12 +66,16 @@ export const StoreProduct: Record<string, Resolver<Root>> & {
   gtin: ({ referenceId }) => referenceId[0]?.Value ?? '',
   review: () => [],
   aggregateRating: () => ({}),
-  offers: (product): { items: Item[]; product: Root } => {
-    return {
-      items: sortOfferByPrice(product.isVariantOf.items),
-      product,
-    }
-  },
+  offers: (root) =>
+    root.sellers
+      .flatMap((seller) =>
+        enhanceCommercialOffer({
+          offer: seller.commertialOffer,
+          seller,
+          product: root,
+        })
+      )
+      .sort(bestOfferFirst),
   isVariantOf: (root) => root,
   additionalProperty: ({ variations = [] }) => {
     return variations.flatMap(({ name, values }) =>

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

@@ -0,0 +1,24 @@
+import type {
+  CommertialOffer,
+  Seller,
+} from '../clients/search/types/ProductSearchResult'
+import type { EnhancedSku } from './enhanceSku'
+
+export type EnhancedCommercialOffer = CommertialOffer & {
+  seller: Seller
+  product: EnhancedSku
+}
+
+export const enhanceCommercialOffer = ({
+  offer,
+  seller,
+  product,
+}: {
+  offer: CommertialOffer
+  seller: Seller
+  product: EnhancedSku
+}): EnhancedCommercialOffer => ({
+  ...offer,
+  product,
+  seller,
+})

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

@@ -1,33 +1,30 @@
-import type {
-  Item,
-  Seller,
-  CommertialOffer,
-} from '../clients/search/types/ProductSearchResult'
+import type { CommertialOffer } from '../clients/search/types/ProductSearchResult'
 
-export const inStock = (item: Item) =>
-  item.sellers.find((seller) => seller.commertialOffer.AvailableQuantity > 0)
+export const inStock = (offer: Pick<CommertialOffer, 'AvailableQuantity'>) =>
+  offer.AvailableQuantity > 0
 
-export const getFirstSeller = (sellers: Seller[]): Seller | undefined =>
-  sellers[0]
+export const price = (offer: Pick<CommertialOffer, 'spotPrice'>) =>
+  offer.spotPrice ?? 0
+export const sellingPrice = (offer: CommertialOffer) => offer.Price ?? 0
 
-export const getItemPriceByKey = (
-  item: Item,
-  key: keyof CommertialOffer
-): number => getFirstSeller(item.sellers)?.commertialOffer[key] ?? 0
+export const availability = (available: boolean) =>
+  available ? 'https://schema.org/InStock' : 'https://schema.org/OutOfStock'
 
 // Smallest Available Selling Price First
-export const sortOfferByPrice = (items: Item[]): Item[] =>
-  items.sort((a, b) => {
-    if (inStock(a) && !inStock(b)) {
-      return -1
-    }
+export const bestOfferFirst = (
+  a: Pick<CommertialOffer, 'AvailableQuantity' | 'spotPrice'>,
+  b: Pick<CommertialOffer, 'AvailableQuantity' | 'spotPrice'>
+) => {
+  if (inStock(a) && !inStock(b)) {
+    return -1
+  }
 
-    if (!inStock(a) && inStock(b)) {
-      return 1
-    }
+  if (!inStock(a) && inStock(b)) {
+    return 1
+  }
 
-    return getItemPriceByKey(a, 'Price') - getItemPriceByKey(b, 'Price')
-  })
+  return price(a) - price(b)
+}
 
-export const inStockOrderFormItem = (availability: string) =>
-  availability === 'available'
+export const inStockOrderFormItem = (itemAvailability: string) =>
+  itemAvailability === 'available'

package/src/typeDefs/aggregateOffer.graphql

@@ -1,10 +1,25 @@
+"""
+Aggregate offer information, for a given SKU that is available to be fulfilled by multiple sellers.
+"""
 type StoreAggregateOffer {
-  # Highest spot price amongst all sellers
+  """
+  Highest price among all sellers.
+  """
   highPrice: Float!
-  # Lowest spot price amongst all sellers
+  """
+  Lowest price among all sellers.
+  """
   lowPrice: Float!
-  # Number of sellers selling this sku
+  """
+  Number of sellers selling this SKU.
+  """
   offerCount: Int!
+  """
+  ISO code of the currency used for the offer prices.
+  """
   priceCurrency: String!
+  """
+  Array with information on each available offer.
+  """
   offers: [StoreOffer!]!
 }

package/src/typeDefs/aggregateRating.graphql

@@ -1,4 +1,13 @@
+"""
+Average rating, based on multiple ratings or reviews.
+"""
 type StoreAggregateRating {
+  """
+  Value of the aggregate rating.
+  """
   ratingValue: Float!
+  """
+  Total number of ratings.
+  """
   reviewCount: Int!
 }

package/src/typeDefs/author.graphql

@@ -1,3 +1,9 @@
+"""
+information about the author of a product review or rating.
+"""
 type StoreAuthor {
+  """
+  Author name.
+  """
   name: String!
 }

package/src/typeDefs/brand.graphql

@@ -1,3 +1,9 @@
+"""
+Brand of a given product.
+"""
 type StoreBrand {
+  """
+  Brand name.
+  """
   name: String!
 }

package/src/typeDefs/breadcrumb.graphql

@@ -1,10 +1,31 @@
+"""
+Item of a list.
+"""
 type StoreListItem {
+  """
+  List item value.
+  """
   item: String!
+  """
+  Name of the list item.
+  """
   name: String!
+  """
+  Position of the item in the list.
+  """
   position: Int!
 }
 
+"""
+List of items consisting of chain linked web pages, ending with the current page.
+"""
 type StoreBreadcrumbList {
+  """
+  Array with breadcrumb elements.
+  """
   itemListElement: [StoreListItem!]!
+  """
+  Number of breadcrumbs in the list.
+  """
   numberOfItems: Int!
 }

package/src/typeDefs/cart.graphql

@@ -1,13 +1,37 @@
+"""
+Shopping cart message.
+"""
 type StoreCartMessage {
+  """
+  Shopping cart message text.
+  """
   text: String!
+  """
+  Shopping cart message status, which can be `INFO`, `WARNING` OR `ERROR`.
+  """
   status: StoreStatus!
 }
 
+"""
+Shopping cart information.
+"""
 type StoreCart {
+  """
+  Order information, including `orderNumber` and `acceptedOffer`.
+  """
   order: StoreOrder!
+  """
+  List of shopping cart messages.
+  """
   messages: [StoreCartMessage!]!
 }
 
+"""
+Shopping cart identification input.
+"""
 input IStoreCart {
+  """
+  Order information, including `orderNumber` and `acceptedOffer`.
+  """
   order: IStoreOrder!
 }

package/src/typeDefs/collection.graphql

@@ -1,3 +1,6 @@
+"""
+Product collection type. Possible values are `Department`, `Category`, `Brand` or `Cluster`.
+"""
 enum StoreCollectionType {
   Department
   Category
@@ -5,22 +8,56 @@ enum StoreCollectionType {
   Cluster
 }
 
+"""
+Product collection facet, used for search.
+"""
 type StoreCollectionFacet {
+  """
+  Facet key.
+  """
   key: String!
+  """
+  Facet value.
+  """
   value: String!
 }
 
+"""
+Collection meta information. Used for search.
+"""
 type StoreCollectionMeta {
+  """
+  List of selected collection facets.
+  """
   selectedFacets: [StoreCollectionFacet!]!
 }
 
+"""
+Product collection information.
+"""
 type StoreCollection {
-  # Meta tag data
+  """
+  Meta tag data.
+  """
   seo: StoreSeo!
-  # location for structured data
+  """
+  List of items consisting of chain linked web pages, ending with the current page.
+  """
   breadcrumbList: StoreBreadcrumbList!
+  """
+  Collection meta information. Used for search.
+  """
   meta: StoreCollectionMeta!
+  """
+  Collection ID.
+  """
   id: ID!
+  """
+  Corresponding collection URL slug, with which to retrieve this entity.
+  """
   slug: String!
+  """
+  Collection type.
+  """
   type: StoreCollectionType!
 }

package/src/typeDefs/facet.graphql

@@ -1,14 +1,43 @@
+"""
+Search facet information.
+"""
 type StoreFacet {
+  """
+  Facet key.
+  """
   key: String!
+  """
+  Facet label.
+  """
   label: String!
+  """
+  Array with information on each facet value.
+  """
   values: [StoreFacetValue!]!
+  """
+  Facet type. Possible values are `BOOLEAN` and `RANGE`.
+  """
   type: StoreFacetType!
 }
 
+"""
+Information of a specific facet value.
+"""
 type StoreFacetValue {
+  """
+  Facet value.
+  """
   value: String!
+  """
+  Facet value label.
+  """
   label: String!
+  """
+  Indicates whether facet is selected.
+  """
   selected: Boolean!
-  # Number of items with this facet
+  """
+  Number of items with this facet.
+  """
   quantity: Int!
 }