@faststore/api 1.2.23

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

@@ -0,0 +1,115 @@
+import { enhanceSku } from '../utils/enhanceSku'
+import { transformSelectedFacet } from '../utils/facets'
+import { SORT_MAP } from '../utils/sort'
+import type {
+  QueryProductArgs,
+  QueryAllCollectionsArgs,
+  QueryAllProductsArgs,
+  QuerySearchArgs,
+} from '../../../__generated__/schema'
+import type { CategoryTree } from '../clients/commerce/types/CategoryTree'
+import type { Context } from '../index'
+
+export const Query = {
+  product: async (_: unknown, { locator }: QueryProductArgs, ctx: Context) => {
+    const {
+      loaders: { skuLoader },
+    } = ctx
+
+    return skuLoader.load(locator.map(transformSelectedFacet))
+  },
+  search: async (
+    _: unknown,
+    { first, after: maybeAfter, sort, term, selectedFacets }: QuerySearchArgs
+  ) => {
+    const after = maybeAfter ? Number(maybeAfter) : 0
+    const searchArgs = {
+      page: Math.ceil(after / first),
+      count: first,
+      query: term,
+      sort: SORT_MAP[sort ?? 'score_desc'],
+      selectedFacets: selectedFacets?.map(transformSelectedFacet) ?? [],
+    }
+
+    return searchArgs
+  },
+  allProducts: async (
+    _: unknown,
+    { first, after: maybeAfter }: QueryAllProductsArgs,
+    ctx: Context
+  ) => {
+    const {
+      clients: { search },
+    } = ctx
+
+    const after = maybeAfter ? Number(maybeAfter) : 0
+    const products = await search.products({
+      page: Math.ceil(after / first),
+      count: first,
+    })
+
+    const skus = products.products
+      .map((product) => product.skus.map((sku) => enhanceSku(sku, product)))
+      .flat()
+      .filter((sku) => sku.sellers.length > 0)
+
+    return {
+      pageInfo: {
+        hasNextPage: products.pagination.after.length > 0,
+        hasPreviousPage: products.pagination.before.length > 0,
+        startCursor: '0',
+        endCursor: products.total.toString(),
+        totalCount: products.total,
+      },
+      edges: skus.map((sku, index) => ({
+        node: sku,
+        cursor: (after + index).toString(),
+      })),
+    }
+  },
+  allCollections: async (
+    _: unknown,
+    __: QueryAllCollectionsArgs,
+    ctx: Context
+  ) => {
+    const {
+      clients: { commerce },
+    } = ctx
+
+    const [brands, tree] = await Promise.all([
+      commerce.catalog.brand.list(),
+      commerce.catalog.category.tree(),
+    ])
+
+    const categories: Array<CategoryTree & { level: number }> = []
+    const dfs = (node: CategoryTree, level: number) => {
+      categories.push({ ...node, level })
+
+      for (const child of node.children) {
+        dfs(child, level + 1)
+      }
+    }
+
+    for (const node of tree) {
+      dfs(node, 0)
+    }
+
+    const collections = [
+      ...brands.map((x) => ({ ...x, type: 'brand' })),
+      ...categories,
+    ]
+
+    return {
+      pageInfo: {
+        hasNextPage: false,
+        hasPreviousPage: false,
+        startCursor: '0',
+        endCursor: '0',
+      },
+      edges: collections.map((node, index) => ({
+        node,
+        cursor: index.toString(),
+      })),
+    }
+  },
+}

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

@@ -0,0 +1,11 @@
+import type { Resolver } from '..'
+
+export const StoreReview: Record<string, Resolver> = {
+  reviewRating: () => ({
+    ratingValue: 5,
+    bestRating: 5,
+  }),
+  author: () => ({
+    name: '',
+  }),
+}

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

@@ -0,0 +1,46 @@
+import { enhanceSku } from '../utils/enhanceSku'
+import type { Resolver } from '..'
+import type { SearchArgs } from '../clients/search'
+
+type Root = Omit<SearchArgs, 'type'>
+
+export const StoreSearchResult: Record<string, Resolver<Root>> = {
+  products: async (searchArgs, _, ctx) => {
+    const {
+      clients: { search },
+    } = ctx
+
+    const products = await search.products(searchArgs)
+
+    const skus = products.products
+      .map((product) => {
+        const maybeSku = product.skus.find((x) => x.sellers.length > 0)
+
+        return maybeSku && enhanceSku(maybeSku, product)
+      })
+      .filter((sku) => !!sku)
+
+    return {
+      pageInfo: {
+        hasNextPage: products.pagination.after.length > 0,
+        hasPreviousPage: products.pagination.before.length > 0,
+        startCursor: '0',
+        endCursor: products.total.toString(),
+        totalCount: products.total,
+      },
+      edges: skus.map((sku, index) => ({
+        node: sku,
+        cursor: index.toString(),
+      })),
+    }
+  },
+  facets: async (searchArgs, _, ctx) => {
+    const {
+      clients: { search: is },
+    } = ctx
+
+    const facets = await is.facets(searchArgs)
+
+    return facets.attributes
+  },
+}

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

@@ -0,0 +1,10 @@
+import type { Resolver } from '..'
+
+type Root = { title?: string; description?: string }
+
+export const StoreSeo: Record<string, Resolver<Root>> = {
+  title: ({ title }) => title ?? '',
+  description: ({ description }) => description ?? '',
+  titleTemplate: () => '',
+  canonical: () => '',
+}

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

@@ -0,0 +1,166 @@
+import deepEquals from 'fast-deep-equal'
+
+import type { IStoreCart, IStoreOffer } from '../../../__generated__/schema'
+import type {
+  OrderForm,
+  OrderFormItem,
+  OrderFormInputItem,
+} from '../clients/commerce/types/OrderForm'
+import type { Context } from '..'
+
+type Indexed<T> = T & { index?: number }
+
+const getId = (item: IStoreOffer) =>
+  [item.itemOffered.sku, item.seller.identifier, item.price].join('::')
+
+const orderFormItemToOffer = (
+  item: OrderFormItem,
+  index?: number
+): Indexed<IStoreOffer> => ({
+  listPrice: item.listPrice / 100,
+  price: item.sellingPrice / 100,
+  quantity: item.quantity,
+  seller: { identifier: item.seller },
+  itemOffered: {
+    sku: item.id,
+    image: [],
+    name: item.name,
+  },
+  index,
+})
+
+const offerToOrderItemInput = (
+  offer: Indexed<IStoreOffer>
+): OrderFormInputItem => ({
+  quantity: offer.quantity,
+  seller: offer.seller.identifier,
+  id: offer.itemOffered.sku,
+  index: offer.index,
+})
+
+const groupById = (offers: IStoreOffer[]): Map<string, IStoreOffer> =>
+  offers.reduce((acc, item) => {
+    const id = getId(item)
+
+    acc.set(id, acc.get(id) ?? item)
+
+    return acc
+  }, new Map<string, IStoreOffer>())
+
+const equals = (of1: OrderForm, of2: OrderForm) => {
+  const pick = ({ orderFormId, messages, items, salesChannel }: OrderForm) => ({
+    orderFormId,
+    messages,
+    salesChannel,
+    items: items.map(
+      ({ uniqueId, quantity, seller, sellingPrice, availability }) => ({
+        uniqueId,
+        quantity,
+        seller,
+        sellingPrice,
+        availability,
+      })
+    ),
+  })
+
+  return deepEquals(pick(of1), pick(of2))
+}
+
+/**
+ * This resolver implements the optimistic cart behavior. The main idea in here
+ * is that we receive a cart from the UI (as query params) and we validate it with
+ * the commerce platform. If the cart is valid, we return null, if the cart is
+ * invalid according to the commerce platform, we return the new cart the UI should use
+ * instead
+ *
+ * The algoritm is something like:
+ * 1. Fetch orderForm from VTEX
+ * 2. Compute delta changes between the orderForm and the UI's cart
+ * 3. Update the orderForm in VTEX platform accordingly
+ * 4. If any chages were made, send to the UI the new cart. Null otherwise
+ */
+export const validateCart = async (
+  _: unknown,
+  {
+    cart: {
+      order: { orderNumber, acceptedOffer },
+    },
+  }: { cart: IStoreCart },
+  ctx: Context
+) => {
+  const {
+    clients: { commerce },
+    loaders: { skuLoader },
+  } = ctx
+
+  // Step1: Get OrderForm from VTEX Commerce
+  const orderForm = await commerce.checkout.orderForm({
+    id: orderNumber,
+  })
+
+  // Step2: Process items from both browser and checkout so they have the same shape
+  const browserItemsById = groupById(acceptedOffer)
+  const originItemsById = groupById(orderForm.items.map(orderFormItemToOffer))
+  const browserItems = Array.from(browserItemsById.values()) // items on the user's browser
+  const originItems = Array.from(originItemsById.values()) // items on the VTEX platform backend
+
+  // Step3: Compute delta changes
+  const { itemsToAdd, itemsToUpdate } = browserItems.reduce(
+    (acc, item) => {
+      const maybeOriginItem = originItemsById.get(getId(item))
+
+      if (!maybeOriginItem) {
+        acc.itemsToAdd.push(item)
+      } else {
+        acc.itemsToUpdate.push({
+          ...maybeOriginItem,
+          quantity: item.quantity,
+        })
+      }
+
+      return acc
+    },
+    {
+      itemsToAdd: [] as IStoreOffer[],
+      itemsToUpdate: [] as IStoreOffer[],
+    }
+  )
+
+  const itemsToDelete = originItems
+    .filter((item) => !browserItemsById.has(getId(item)))
+    .map((item) => ({ ...item, quantity: 0 }))
+
+  const changes = [...itemsToAdd, ...itemsToUpdate, ...itemsToDelete].map(
+    offerToOrderItemInput
+  )
+
+  if (changes.length === 0) {
+    return null
+  }
+
+  // Step4: Apply delta changes to order form
+  const updatedOrderForm = await commerce.checkout.updateOrderFormItems({
+    id: orderForm.orderFormId,
+    orderItems: changes,
+  })
+
+  // Step5: If no changes detected before/after updating orderForm, the order is validated
+  if (equals(orderForm, updatedOrderForm)) {
+    return null
+  }
+
+  // Step6: There were changes, convert orderForm to StoreOrder
+  return {
+    order: {
+      orderNumber: updatedOrderForm.orderFormId,
+      acceptedOffer: updatedOrderForm.items.map((item) => ({
+        ...item,
+        product: skuLoader.load([{ key: 'id', value: item.id }]), // TODO: add channel
+      })),
+    },
+    messages: updatedOrderForm.messages.map(({ text, status }) => ({
+      text,
+      status: status.toUpperCase(),
+    })),
+  }
+}

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

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

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

@@ -0,0 +1,31 @@
+export interface SelectedFacet {
+  key: string
+  value: string
+}
+
+const getIdFromSlug = (slug: string) => {
+  const id = slug.split('-').pop()
+
+  if (id == null) {
+    throw new Error('Error while extracting sku id from product slug')
+  }
+
+  return id
+}
+
+/**
+ * Transform facets from the store to VTEX platform facets.
+ * For instance, the channel in Store becames trade-policy in VTEX's realm
+ * */
+export const transformSelectedFacet = ({ key, value }: SelectedFacet) => {
+  switch (key) {
+    case 'channel':
+      return { key: 'trade-policy', value }
+
+    case 'slug':
+      return { key: 'id', value: getIdFromSlug(value) }
+
+    default:
+      return { key, value }
+  }
+}

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

@@ -0,0 +1,4 @@
+import rawSlugify from 'slugify'
+
+export const slugify = (path: string) =>
+  rawSlugify(path, { replacement: '-', lower: true })

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

@@ -0,0 +1,10 @@
+export const SORT_MAP = {
+  price_desc: 'price:desc',
+  price_asc: 'price:asc',
+  orders_desc: 'orders:desc',
+  name_desc: 'name:desc',
+  name_asc: 'name:asc',
+  release_desc: 'release:desc',
+  discount_desc: 'discount:desc',
+  score_desc: '',
+} as const

package/src/typeDefs/aggregateOffer.graphql

@@ -0,0 +1,10 @@
+type StoreAggregateOffer {
+  # Highest spot price amongst all sellers
+  highPrice: Float!
+  # Lowest spot price amongst all sellers
+  lowPrice: Float!
+  # Number of sellers selling this sku
+  offerCount: Int!
+  priceCurrency: String!
+  offers: [StoreOffer!]!
+}

package/src/typeDefs/aggregateRating.graphql

@@ -0,0 +1,4 @@
+type StoreAggregateRating {
+  ratingValue: Float!
+  reviewCount: Int!
+}

package/src/typeDefs/author.graphql

@@ -0,0 +1,3 @@
+type StoreAuthor {
+  name: String!
+}

package/src/typeDefs/brand.graphql

@@ -0,0 +1,3 @@
+type StoreBrand {
+  name: String!
+}

package/src/typeDefs/breadcrumb.graphql

@@ -0,0 +1,10 @@
+type StoreListItem {
+  item: String!
+  name: String!
+  position: Int!
+}
+
+type StoreBreadcrumbList {
+  itemListElement: [StoreListItem!]!
+  numberOfItems: Int!
+}

package/src/typeDefs/cart.graphql

@@ -0,0 +1,13 @@
+type StoreCartMessage {
+  text: String!
+  status: StoreStatus!
+}
+
+type StoreCart {
+  order: StoreOrder!
+  messages: [StoreCartMessage!]!
+}
+
+input IStoreCart {
+  order: IStoreOrder!
+}

package/src/typeDefs/collection.graphql

@@ -0,0 +1,26 @@
+enum StoreCollectionType {
+  Department
+  Category
+  Brand
+  Cluster
+}
+
+type StoreCollectionFacet {
+  key: String!
+  value: String!
+}
+
+type StoreCollectionMeta {
+  selectedFacets: [StoreCollectionFacet!]!
+}
+
+type StoreCollection {
+  # Meta tag data
+  seo: StoreSeo!
+  # location for structured data
+  breadcrumbList: StoreBreadcrumbList!
+  meta: StoreCollectionMeta!
+  id: ID!
+  slug: String!
+  type: StoreCollectionType!
+}

package/src/typeDefs/facet.graphql

@@ -0,0 +1,14 @@
+type StoreFacet {
+  key: String!
+  label: String!
+  values: [StoreFacetValue!]!
+  type: StoreFacetType!
+}
+
+type StoreFacetValue {
+  value: String!
+  label: String!
+  selected: Boolean!
+  # Number of items with this facet
+  quantity: Int!
+}

package/src/typeDefs/image.graphql

@@ -0,0 +1,9 @@
+type StoreImage {
+  url: String!
+  alternateName: String!
+}
+
+input IStoreImage {
+  url: String!
+  alternateName: String!
+}

package/src/typeDefs/index.ts

@@ -0,0 +1,47 @@
+import { print } from 'graphql'
+
+import AggregateOffer from './aggregateOffer.graphql'
+import AggregateRating from './aggregateRating.graphql'
+import Author from './author.graphql'
+import Brand from './brand.graphql'
+import Breadcrumb from './breadcrumb.graphql'
+import Collection from './collection.graphql'
+import Facet from './facet.graphql'
+import Image from './image.graphql'
+import Mutation from './mutation.graphql'
+import Offer from './offer.graphql'
+import Order from './order.graphql'
+import Organization from './organization.graphql'
+import PageInfo from './pageInfo.graphql'
+import Product from './product.graphql'
+import ProductGroup from './productGroup.graphql'
+import Query from './query.graphql'
+import Review from './review.graphql'
+import Seo from './seo.graphql'
+import Cart from './cart.graphql'
+import Status from './status.graphql'
+
+export const typeDefs = [
+  Query,
+  Mutation,
+  Brand,
+  Breadcrumb,
+  Collection,
+  Facet,
+  Image,
+  PageInfo,
+  Product,
+  Seo,
+  Offer,
+  AggregateRating,
+  Review,
+  Author,
+  ProductGroup,
+  Organization,
+  AggregateOffer,
+  Order,
+  Cart,
+  Status,
+]
+  .map(print)
+  .join('\n')

package/src/typeDefs/mutation.graphql

@@ -0,0 +1,4 @@
+type Mutation {
+  # Returns the order if anything changed with the order. Null if the order is valid
+  validateCart(cart: IStoreCart!): StoreCart
+}

package/src/typeDefs/offer.graphql

@@ -0,0 +1,21 @@
+type StoreOffer {
+  listPrice: Float!
+  sellingPrice: Float!
+  priceCurrency: String!
+  # Also known as spotPrice
+  price: Float!
+  priceValidUntil: String!
+  itemCondition: String!
+  availability: String!
+  seller: StoreOrganization!
+  itemOffered: StoreProduct!
+  quantity: Int!
+}
+
+input IStoreOffer {
+  price: Float!
+  listPrice: Float!
+  seller: IStoreOrganization!
+  itemOffered: IStoreProduct!
+  quantity: Int!
+}

package/src/typeDefs/order.graphql

@@ -0,0 +1,9 @@
+type StoreOrder {
+  orderNumber: String!
+  acceptedOffer: [StoreOffer!]!
+}
+
+input IStoreOrder {
+  orderNumber: String!
+  acceptedOffer: [IStoreOffer!]!
+}

package/src/typeDefs/organization.graphql

@@ -0,0 +1,7 @@
+type StoreOrganization {
+  identifier: String!
+}
+
+input IStoreOrganization {
+  identifier: String!
+}

package/src/typeDefs/pageInfo.graphql

@@ -0,0 +1,8 @@
+type StorePageInfo {
+  hasNextPage: Boolean!
+  hasPreviousPage: Boolean!
+  startCursor: String!
+  endCursor: String!
+  # Total number of items(products/collections), not pages
+  totalCount: Int!
+}

package/src/typeDefs/product.graphql

@@ -0,0 +1,25 @@
+type StoreProduct {
+  # Meta tag data
+  seo: StoreSeo!
+  # Location for structured data
+  breadcrumbList: StoreBreadcrumbList!
+  # Where to retrieve this entity
+  slug: String!
+  name: String!
+  productID: String!
+  brand: StoreBrand!
+  description: String!
+  image: [StoreImage!]!
+  offers: StoreAggregateOffer!
+  sku: String!
+  gtin: String!
+  review: [StoreReview!]!
+  aggregateRating: StoreAggregateRating!
+  isVariantOf: StoreProductGroup!
+}
+
+input IStoreProduct {
+  sku: String!
+  name: String!
+  image: [IStoreImage!]!
+}

package/src/typeDefs/productGroup.graphql

@@ -0,0 +1,5 @@
+type StoreProductGroup {
+  hasVariant: [StoreProduct!]!
+  productGroupID: String!
+  name: String!
+}