@faststore/api 1.2.23

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

@@ -0,0 +1,223 @@
+export interface ProductSearchResult {
+  total: number
+  products: Product[]
+  pagination: Pagination
+  sampling: boolean
+  options: Options
+  translated: boolean
+  locale: string
+  query: string
+  operator: string
+  fuzzy: string
+  correction: Correction
+}
+
+export interface Correction {
+  misspelled: boolean
+}
+
+export interface Options {
+  sorts: Sort[]
+  counts: Count[]
+}
+
+export interface Count {
+  count: number
+  proxyURL: string
+}
+
+export interface Sort {
+  field: string
+  order: string
+  active?: boolean
+  proxyURL: string
+}
+
+export interface Pagination {
+  count: number
+  current: Current
+  before: any[]
+  after: Current[]
+  perPage: number
+  next: Current
+  previous: First
+  first: First
+  last: Current
+}
+
+export interface Current {
+  index: number
+  proxyURL: string
+}
+
+export interface First {
+  index: number
+}
+
+export interface Product {
+  unitMultiplier: number
+  year: number
+  extraData: ExtraDatum[]
+  release: number
+  discount: number
+  reference: string
+  split: Split
+  collections: Collection[]
+  price: number
+  customSort: number
+  stickers: Sticker[]
+  id: string
+  stock: number
+  brand: string
+  availableTradePolicies: string[]
+  categoryTrees: CategoryTree[]
+  images: Image[]
+  locationAttributes: any[]
+  tax: number
+  productScore: number
+  storeSplitAttribute: string
+  brandID: string
+  installment: Installment
+  name: string
+  boost: Boost
+  skus: Sku[]
+  link: string
+  wear: number
+  description: string
+  showIfNotAvailable: boolean
+  clusterHighlights: ClusterHighlights
+  categories: string[]
+  timestamp: number
+  product: string
+  oldPrice: number
+  productSpecifications: any[]
+  url: string
+  measurementUnit: string
+  categoryIDS: string[]
+  textAttributes: TextAttribute[]
+  numberAttributes: NumberAttribute[]
+  headSku: string
+  specificationGroups: string
+  extraInfo: ExtraInfo
+  oldPriceText: string
+  priceText: string
+}
+
+export interface Boost {
+  newness: number
+  image: number
+  revenue: number
+  discount: number
+  productScore: number
+  click: number
+  availableSpecsCount: number
+  promotion: number
+  order: number
+}
+
+export interface CategoryTree {
+  categoryNames: string[]
+  categoryIDS: string[]
+}
+
+export interface ClusterHighlights {
+  the140: string
+}
+
+export interface Collection {
+  id: string
+  position: number
+}
+
+export interface ExtraDatum {
+  value: string
+  key: string
+}
+
+export interface ExtraInfo {
+  sellerID: string
+}
+
+export interface Image {
+  name: string
+  value: string
+}
+
+export interface Installment {
+  interest: boolean
+  count: number
+  paymentGroupName: string
+  value: number
+  paymentName: string
+  valueText?: string
+}
+
+export interface NumberAttribute {
+  labelKey: string
+  value: number
+  key: string
+}
+
+export interface Sku {
+  images: Image[]
+  nameComplete: string
+  complementName: string
+  policies: Policy[]
+  videos: any[]
+  reference: string
+  idWithSplit: string
+  ean: string
+  name: string
+  attributes: ExtraDatum[]
+  id: string
+  sellers: Seller[]
+}
+
+export interface Policy {
+  id: string
+  sellers: Seller[]
+}
+
+export interface Seller {
+  default: boolean
+  oldPrice?: number
+  price?: number
+  installment?: Installment
+  name: string
+  tax: number
+  teasers: any[]
+  id: string
+}
+
+export interface Split {
+  labelValue: string
+  labelKey: string
+}
+
+export interface Sticker {
+  image: string
+  name: string
+  location: string
+  target: string
+}
+
+export interface TextAttribute {
+  joinedValue: string
+  isSku: boolean
+  joinedKey: string
+  joinedKeyTranslations: JoinedTranslations
+  isFilter: boolean
+  labelValue: string
+  id: string[]
+  labelKey: string
+  value: string
+  key: string
+  joinedValueTranslations: JoinedTranslations
+  valueID?: string
+}
+
+export interface JoinedTranslations {
+  spanish: string
+  english: string
+  italian: string
+}

package/src/platforms/vtex/index.ts

@@ -0,0 +1,62 @@
+import { getClients } from './clients'
+import { getLoaders } from './loaders'
+import { StoreAggregateOffer } from './resolvers/aggregateOffer'
+import { StoreAggregateRating } from './resolvers/aggregateRating'
+import { StoreCollection } from './resolvers/collection'
+import { StoreFacet } from './resolvers/facet'
+import { StoreFacetValue } from './resolvers/facetValue'
+import { Mutation } from './resolvers/mutation'
+import { StoreOffer } from './resolvers/offer'
+import { StoreProduct } from './resolvers/product'
+import { StoreProductGroup } from './resolvers/productGroup'
+import { Query } from './resolvers/query'
+import { StoreReview } from './resolvers/review'
+import { StoreSearchResult } from './resolvers/searchResult'
+import { StoreSeo } from './resolvers/seo'
+import type { Loaders } from './loaders'
+import type { Clients } from './clients'
+
+export interface Options {
+  platform: 'vtex'
+  account: string
+  environment: 'vtexcommercestable' | 'vtexcommercebeta'
+  // Default sales channel to use for fetching products
+  channel: string
+}
+
+export interface Context {
+  clients: Clients
+  loaders: Loaders
+}
+
+export type Resolver<R = unknown, A = unknown> = (
+  root: R,
+  args: A,
+  ctx: Context,
+  info: any
+) => any
+
+const Resolvers = {
+  StoreCollection,
+  StoreAggregateOffer,
+  StoreProduct,
+  StoreSeo,
+  StoreFacet,
+  StoreFacetValue,
+  StoreOffer,
+  StoreAggregateRating,
+  StoreReview,
+  StoreProductGroup,
+  StoreSearchResult,
+  Query,
+  Mutation,
+}
+
+export const getContextFactory = (options: Options) => (ctx: any) => {
+  ctx.clients = getClients(options)
+  ctx.loaders = getLoaders(options, ctx.clients)
+
+  return ctx
+}
+
+export const getResolvers = (_: Options) => Resolvers

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

@@ -0,0 +1,16 @@
+import { getSimulationLoader } from './simulation'
+import { getSkuLoader } from './sku'
+import type { Options } from '..'
+import type { Clients } from '../clients'
+
+export type Loaders = ReturnType<typeof getLoaders>
+
+export const getLoaders = (options: Options, clients: Clients) => {
+  const skuLoader = getSkuLoader(options, clients)
+  const simulationLoader = getSimulationLoader(options, clients)
+
+  return {
+    skuLoader,
+    simulationLoader,
+  }
+}

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

@@ -0,0 +1,42 @@
+import DataLoader from 'dataloader'
+
+import type {
+  PayloadItem,
+  Simulation,
+} from '../clients/commerce/types/Simulation'
+import type { Options } from '..'
+import type { Clients } from '../clients'
+
+export const getSimulationLoader = (_: Options, clients: Clients) => {
+  const loader = async (items: readonly PayloadItem[][]) => {
+    const simulated = await clients.commerce.checkout.simulation({
+      items: [...items.flat()],
+    })
+
+    const itemsIndices = items.reduce(
+      (acc, curr) => [...acc, curr.length + acc[acc.length - 1]],
+      [0]
+    )
+
+    if (simulated.items.length !== itemsIndices[itemsIndices.length - 1]) {
+      const askedItems = itemsIndices[itemsIndices.length - 1]
+      const returnedItems = simulated.items.length
+
+      throw new Error(
+        `Simulation asked for ${askedItems}, but received ${returnedItems} items`
+      )
+    }
+
+    return items.map((__, index) => ({
+      ...simulated,
+      items: simulated.items.slice(
+        itemsIndices[index],
+        itemsIndices[index + 1]
+      ),
+    }))
+  }
+
+  return new DataLoader<PayloadItem[], Simulation>(loader, {
+    maxBatchSize: 20,
+  })
+}

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

@@ -0,0 +1,61 @@
+import DataLoader from 'dataloader'
+
+import { enhanceSku } from '../utils/enhanceSku'
+import type { EnhancedSku } from '../utils/enhanceSku'
+import type { Options } from '..'
+import type { Clients } from '../clients'
+import type { SelectedFacet } from '../utils/facets'
+
+export const getSkuLoader = (_: Options, clients: Clients) => {
+  const loader = async (facetsList: readonly SelectedFacet[][]) => {
+    const skuIds = facetsList.map((facets) => {
+      const maybeFacet = facets.find(({ key }) => key === 'id')
+
+      if (!maybeFacet) {
+        throw new Error(
+          'Error while loading SKU. Needs to pass an id to selected facets'
+        )
+      }
+
+      return maybeFacet.value
+    })
+
+    const indexById = skuIds.reduce(
+      (acc, id, index) => ({ ...acc, [id]: index }),
+      {} as Record<string, number>
+    )
+
+    const { products } = await clients.search.products({
+      query: `sku:${skuIds.join(';')}`,
+      page: 0,
+      count: skuIds.length,
+    })
+
+    if (products.length !== skuIds.length) {
+      throw new Error(
+        `Sku batching went wrong. Asked for ${skuIds.length} sku(s) but search api returned ${products.length} sku(s)`
+      )
+    }
+
+    const sorted = new Array<EnhancedSku>(products.length)
+
+    // O(n*m) sort, where n = skuIds.length and m is the number of skus per product
+    for (const product of products) {
+      const sku = product.skus.find((item) => indexById[item.id] != null)
+
+      if (sku == null) {
+        throw new Error(`Could not find sku for product ${product.id}`)
+      }
+
+      const index = indexById[sku.id]
+
+      sorted[index] = enhanceSku(sku, product)
+    }
+
+    return sorted
+  }
+
+  return new DataLoader<SelectedFacet[], EnhancedSku>(loader, {
+    maxBatchSize: 99, // Max allowed batch size of Search API
+  })
+}

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

@@ -0,0 +1,20 @@
+import type { EnhancedSku } from '../utils/enhanceSku'
+import type { Simulation } from '../clients/commerce/types/Simulation'
+
+type Resolvers = (root: Simulation & { product: EnhancedSku }) => unknown
+
+export const StoreAggregateOffer: Record<string, Resolvers> = {
+  highPrice: ({ items }) =>
+    items.reduce(
+      (acc, curr) => (acc > curr.sellingPrice ? acc : curr.sellingPrice),
+      items[0]?.sellingPrice ?? 0
+    ) / 1e2,
+  lowPrice: ({ items }) =>
+    items.reduce(
+      (acc, curr) => (acc < curr.sellingPrice ? acc : curr.sellingPrice),
+      items[0]?.sellingPrice ?? 0
+    ) / 1e2,
+  offerCount: ({ items }) => items.length,
+  priceCurrency: () => '',
+  offers: ({ items, product }) => items.map((item) => ({ ...item, product })),
+}

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

@@ -0,0 +1,7 @@
+import type { Resolver } from '..'
+
+// TODO: Add a review system integration
+export const StoreAggregateRating: Record<string, Resolver> = {
+  ratingValue: () => 5,
+  reviewCount: () => 0,
+}

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

@@ -0,0 +1,43 @@
+import type { Resolver } from '..'
+import type { Brand } from '../clients/commerce/types/Brand'
+import type { CategoryTree } from '../clients/commerce/types/CategoryTree'
+import { slugify } from '../utils/slugify'
+
+type Root = Brand | (CategoryTree & { level: number })
+
+const isBrand = (x: any): x is Brand => x.type === 'brand'
+
+export const StoreCollection: Record<string, Resolver<Root>> = {
+  id: ({ id }) => id.toString(),
+  slug: ({ name }) => slugify(name),
+  seo: (root) =>
+    isBrand(root)
+      ? {
+          title: root.title,
+          description: root.metaTagDescription,
+        }
+      : {
+          title: root.Title,
+          description: root.MetaTagDescription,
+        },
+  type: (root) =>
+    isBrand(root) ? 'Brand' : root.level === 0 ? 'Department' : 'Category',
+  meta: (root) =>
+    isBrand(root)
+      ? {
+          selectedFacets: [{ key: 'brand', value: slugify(root.name) }],
+        }
+      : {
+          selectedFacets: new URL(root.url).pathname
+            .slice(1)
+            .split('/')
+            .map((segment, index) => ({
+              key: `category-${index + 1}`,
+              value: slugify(segment),
+            })),
+        },
+  breadcrumbList: () => ({
+    itemListElement: [],
+    numberOfItems: 0,
+  }),
+}

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

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

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

@@ -0,0 +1,11 @@
+import type { Resolver } from '..'
+import type { Value } from '../clients/search/types/AttributeSearchResult'
+
+type Root = Value
+
+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,
+}

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

@@ -0,0 +1,5 @@
+import { validateCart } from './validateCart'
+
+export const Mutation = {
+  validateCart,
+}

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

@@ -0,0 +1,26 @@
+import type { EnhancedSku } from '../utils/enhanceSku'
+import type { Resolver } from '..'
+import type { Item } from '../clients/commerce/types/Simulation'
+import type { OrderFormItem } from '../clients/commerce/types/OrderForm'
+
+type Root =
+  | (Item & { product: EnhancedSku }) // when querying search/product
+  | (OrderFormItem & { product: Promise<EnhancedSku> }) // when querying order
+
+export const StoreOffer: Record<string, Resolver<Root>> = {
+  priceCurrency: () => '',
+  priceValidUntil: ({ priceValidUntil }) => priceValidUntil ?? '',
+  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,
+  itemOffered: ({ product }) => product,
+  quantity: ({ quantity }) => quantity,
+}

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

@@ -0,0 +1,5 @@
+import type { Resolver } from '..'
+
+export const StoreOrganization: Record<string, Resolver> = {
+  identifier: () => '',
+}

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

@@ -0,0 +1,75 @@
+import type { Resolver } from '..'
+import type { EnhancedSku } from '../utils/enhanceSku'
+
+type Root = EnhancedSku
+
+const DEFAULT_IMAGE = {
+  name: 'image',
+  value:
+    'https://storecomponents.vtexassets.com/assets/faststore/images/image___117a6d3e229a96ad0e0d0876352566e2.svg',
+}
+
+const getSlug = (link: string, id: string) => `${link}-${id}`
+const getPath = (link: string, id: string) => `/${getSlug(link, id)}/p`
+
+export const StoreProduct: Record<string, Resolver<Root>> = {
+  productID: ({ id }) => id,
+  name: ({ isVariantOf, name }) => name ?? isVariantOf.name,
+  slug: ({ isVariantOf: { link }, id }) => getSlug(link, id),
+  description: ({ isVariantOf: { description } }) => description,
+  seo: ({ isVariantOf: { name, description } }) => ({
+    title: name,
+    description,
+  }),
+  brand: ({ isVariantOf: { brand } }) => ({ name: brand }),
+  breadcrumbList: ({ isVariantOf: { categoryTrees, name, link }, id }) => ({
+    itemListElement: [
+      ...categoryTrees.map(({ categoryNames }, index) => ({
+        name: categoryNames[categoryNames.length - 1],
+        item: `/${categoryNames.join('/').toLowerCase()}`,
+        position: index + 1,
+      })),
+      {
+        name,
+        item: getPath(link, id),
+        position: categoryTrees.length + 1,
+      },
+    ],
+    numberOfItems: categoryTrees.length,
+  }),
+  image: ({ isVariantOf, images }) =>
+    (images ?? isVariantOf.images ?? [DEFAULT_IMAGE]).map(
+      ({ name, value }) => ({
+        alternateName: name ?? '',
+        url: value.replace('vteximg.com.br', 'vtexassets.com'),
+      })
+    ),
+  sku: ({
+    isVariantOf: {
+      skus: [sku],
+    },
+  }) => sku.id,
+  gtin: ({ reference }) => reference ?? '',
+  review: () => [],
+  aggregateRating: () => ({}),
+  offers: async (product, _, ctx) => {
+    const {
+      loaders: { simulationLoader },
+    } = ctx
+
+    const { sellers, id } = product
+
+    // 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)
+
+    return { ...simulation, product }
+  },
+  isVariantOf: ({ isVariantOf }) => isVariantOf,
+}

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

@@ -0,0 +1,9 @@
+import { enhanceSku } from '../utils/enhanceSku'
+import type { Product } from '../clients/search/types/ProductSearchResult'
+import type { Resolver } from '..'
+
+export const StoreProductGroup: Record<string, Resolver<Product>> = {
+  hasVariant: (root) => root.skus.map((sku) => enhanceSku(sku, root)),
+  productGroupID: ({ product }) => product,
+  name: ({ name }) => name,
+}