@faststore/api 3.44.0 → 3.45.0

package/src/platforms/errors.ts

@@ -1,4 +1,8 @@
-type ErrorType = 'BadRequestError' | 'NotFoundError' | 'RedirectError'
+type ErrorType =
+  | 'BadRequestError'
+  | 'NotFoundError'
+  | 'RedirectError'
+  | 'ForbiddenError'
 
 interface Extension {
   type: ErrorType
@@ -27,6 +31,12 @@ export class NotFoundError extends FastStoreError {
   }
 }
 
+export class ForbiddenError extends FastStoreError {
+  constructor(message?: string) {
+    super({ status: 403, type: 'ForbiddenError' }, message)
+  }
+}
+
 export const isFastStoreError = (error: any): error is FastStoreError =>
   error?.name === 'FastStoreError'
 
@@ -35,3 +45,6 @@ export const isNotFoundError = (error: any): error is NotFoundError =>
 
 export const isBadRequestError = (error: any): error is BadRequestError =>
   error?.extensions?.type === 'BadRequestError'
+
+export const isForbiddenError = (error: any): error is ForbiddenError =>
+  error?.extensions?.type === 'ForbiddenError'

package/src/platforms/vtex/clients/commerce/Contract.ts

@@ -0,0 +1,7 @@
+export interface ContractResponse {
+  isCorporate: boolean
+  corporateName: string
+  firstName: string
+  lastName: string
+  userName: string
+}

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

@@ -2,10 +2,22 @@ import { parse } from 'cookie'
 import type { FACET_CROSS_SELLING_MAP } from '../../utils/facets'
 import { fetchAPI } from '../fetch'
 
-import type { StoreMarketingData } from '../../../..'
+import type {
+  IUserOrderCancel,
+  QueryListUserOrdersArgs,
+  StoreMarketingData,
+  UserOrder,
+  UserOrderCancel,
+  UserOrderListResult,
+} from '../../../..'
 import type { Context, Options } from '../../index'
 import type { Channel } from '../../utils/channel'
-import { getStoreCookie, getWithCookie } from '../../utils/cookies'
+import {
+  getStoreCookie,
+  getWithAutCookie,
+  getWithCookie,
+} from '../../utils/cookies'
+import type { ContractResponse } from './Contract'
 import type { Address, AddressInput } from './types/Address'
 import type { Brand } from './types/Brand'
 import type { CategoryTree } from './types/CategoryTree'
@@ -22,6 +34,8 @@ import type {
   SimulationArgs,
   SimulationOptions,
 } from './types/Simulation'
+import type { ScopesByUnit, UnitResponse } from './types/Unit'
+import type { VtexIdResponse } from './types/VtexId'
 
 type ValueOf<T> = T extends Record<string, infer K> ? K : never
 
@@ -39,6 +53,7 @@ export const VtexCommerce = (
   const base = `https://${account}.${environment}.com.br`
   const storeCookies = getStoreCookie(ctx)
   const withCookie = getWithCookie(ctx)
+  const withAutCookie = getWithAutCookie(ctx)
 
   const host =
     new Headers(ctx.headers).get('x-forwarded-host') ?? ctx.headers?.host ?? ''
@@ -351,6 +366,29 @@ export const VtexCommerce = (
           { storeCookies }
         )
       },
+      cancelOrder: ({
+        orderId,
+        customerEmail,
+        reason,
+      }: IUserOrderCancel): Promise<UserOrderCancel> | undefined => {
+        const headers: HeadersInit = withCookie({
+          'content-type': 'application/json',
+          'X-FORWARDED-HOST': forwardedHost,
+        })
+
+        return fetchAPI(
+          `${base}/api/checkout/pub/orders/${orderId}/user-cancel-request`,
+          {
+            method: 'POST',
+            headers,
+            body: JSON.stringify({
+              customerEmail,
+              reason,
+            }),
+          },
+          {}
+        )
+      },
     },
     session: (search: string): Promise<Session> => {
       const params = new URLSearchParams(search)
@@ -392,19 +430,191 @@ export const VtexCommerce = (
     },
     profile: {
       addresses: async (userId: string): Promise<Record<string, string>> => {
+        const headers: HeadersInit = withAutCookie(forwardedHost, account)
+
+        return fetchAPI(
+          `${base}/api/profile-system/pvt/profiles/${userId}/addresses`,
+          { headers },
+          { storeCookies }
+        )
+      },
+    },
+    oms: {
+      userOrder: ({ orderId }: { orderId: string }): Promise<UserOrder> => {
         const headers: HeadersInit = withCookie({
           'content-type': 'application/json',
           'X-FORWARDED-HOST': forwardedHost,
         })
 
-        const cookies = parse(ctx?.headers?.cookie ?? '')
-        const VtexIdclientAutCookie =
-          cookies['VtexIdclientAutCookie_' + account]
-        headers['VtexIdclientAutCookie'] = VtexIdclientAutCookie
+        return fetchAPI(
+          `${base}/api/oms/user/orders/${orderId}`,
+          {
+            method: 'GET',
+            headers,
+          },
+          { storeCookies }
+        )
+      },
+      listUserOrders: ({
+        page,
+        status,
+        dateInitial,
+        dateFinal,
+        text,
+        clientEmail,
+        perPage,
+      }: QueryListUserOrdersArgs): Promise<UserOrderListResult> => {
+        const params = new URLSearchParams()
+
+        if (dateInitial) {
+          const dateInitialTimestamp = new Date(dateInitial).setHours(
+            0,
+            0,
+            0,
+            0
+          )
+          dateInitial = new Date(dateInitialTimestamp).toISOString()
+        }
+        if (dateFinal) {
+          const dateFinalTimestamp = new Date(dateFinal).setHours(
+            23,
+            59,
+            59,
+            999
+          )
+          dateFinal = new Date(dateFinalTimestamp).toISOString()
+        }
+
+        if (text) params.append('text', text)
+        if (status && status.length > 0) {
+          status.forEach((s) =>
+            s && s.length > 0 ? params.append('status', s) : null
+          )
+        }
+
+        if (dateInitial && dateFinal) {
+          params.append(
+            'creation_date',
+            `creationDate:[${dateInitial} TO ${dateFinal}]`
+          )
+        } else if (dateInitial) {
+          params.append('creation_date', `creationDate:[${dateInitial} TO *]`)
+        } else if (dateFinal) {
+          params.append('creation_date', `creationDate:[* TO ${dateFinal}]`)
+        }
+
+        if (clientEmail) params.append('clientEmail', clientEmail)
+        if (page) params.append('page', page.toString())
+        if (perPage) params.append('per_page', perPage.toString())
+
+        const headers: HeadersInit = withCookie({
+          'content-type': 'application/json',
+          'X-FORWARDED-HOST': forwardedHost,
+        })
 
         return fetchAPI(
-          `${base}/api/profile-system/pvt/profiles/${userId}/addresses`,
-          { headers },
+          `${base}/api/oms/user/orders?${params.toString()}`,
+          {
+            method: 'GET',
+            headers,
+          },
+          { storeCookies }
+        )
+      },
+    },
+    units: {
+      getUnitByUserId: ({
+        userId,
+      }: { userId: string }): Promise<UnitResponse> => {
+        const headers: HeadersInit = withAutCookie(forwardedHost, account)
+
+        return fetchAPI(
+          `${base}/api/units/v1/${userId}/unit`,
+          {
+            method: 'GET',
+            headers,
+          },
+          {}
+        )
+      },
+      getOrgUnitById: ({
+        orgUnitId,
+      }: { orgUnitId: string }): Promise<UnitResponse> => {
+        const headers: HeadersInit = withAutCookie(forwardedHost, account)
+
+        return fetchAPI(
+          `${base}/api/units/v1/${orgUnitId}`,
+          {
+            method: 'GET',
+            headers,
+          },
+          {}
+        )
+      },
+      getScopesByOrgUnit: ({
+        orgUnitId,
+      }: { orgUnitId: string }): Promise<ScopesByUnit> => {
+        const headers: HeadersInit = withAutCookie(forwardedHost, account)
+
+        return fetchAPI(
+          `${base}/api/units/v1/${orgUnitId}/scopes`,
+          {
+            method: 'GET',
+            headers,
+          },
+          {}
+        )
+      },
+    },
+    licenseManager: {
+      getUserById: ({
+        userId,
+      }: { userId: string }): Promise<{
+        id: string
+        name: string
+        email: string
+      }> => {
+        const headers: HeadersInit = withAutCookie(forwardedHost, account)
+
+        return fetchAPI(
+          `${base}/api/license-manager/users/${userId}`,
+          {
+            method: 'GET',
+            headers,
+          },
+          {}
+        )
+      },
+    },
+    masterData: {
+      getContractById: ({
+        contractId,
+      }: { contractId: string }): Promise<ContractResponse> => {
+        const headers: HeadersInit = withAutCookie(forwardedHost, account)
+
+        return fetchAPI(
+          `${base}/api/dataentities/CL/documents/${contractId}?_fields=_all`,
+          {
+            method: 'GET',
+            headers,
+          },
+          {}
+        )
+      },
+    },
+    vtexid: {
+      validate: (): Promise<VtexIdResponse> => {
+        const headers: HeadersInit = withAutCookie(forwardedHost, account)
+
+        return fetchAPI(
+          `${base}/api/vtexid/credential/validate`,
+          {
+            headers,
+            body: JSON.stringify({
+              token: headers['VtexIdclientAutCookie'],
+            }),
+            method: 'POST',
+          },
           { storeCookies }
         )
       },

package/src/platforms/vtex/clients/commerce/types/Unit.ts

@@ -0,0 +1,19 @@
+export interface UnitResponse {
+  createdAt: string
+  updatedAt: string
+  name: string
+  path: {
+    ids: string
+    names: string
+  }
+  id: string
+  customerGroup: string[]
+}
+
+export interface ScopesByUnit {
+  organizationUnitId: string
+  scopes: Array<{
+    scope: string
+    ids: string[]
+  }>
+}

package/src/platforms/vtex/clients/commerce/types/VtexId.ts

@@ -0,0 +1,11 @@
+export interface VtexIdResponse {
+  authStatus: string
+  id: string
+  user: string
+  account: string
+  audience: string
+  tokenType: string
+  customerId: string
+  unitName: string
+  isRepresentative: boolean
+}

package/src/platforms/vtex/index.ts

@@ -24,6 +24,7 @@ import { StoreSearchResult } from './resolvers/searchResult'
 import { StoreSeo } from './resolvers/seo'
 import { ShippingSLA } from './resolvers/shippingSLA'
 import { SkuVariants } from './resolvers/skuVariations'
+import { UserOrder } from './resolvers/userOrder'
 import type { Channel } from './utils/channel'
 import ChannelMarshal from './utils/channel'
 
@@ -63,6 +64,7 @@ export interface Context {
     cookies: Map<string, Record<string, string>>
   }
   headers: Record<string, string>
+  account: string
 }
 
 export type Resolver<R = unknown, A = unknown, Return = any> = (
@@ -89,6 +91,7 @@ const Resolvers = {
   StorePropertyValue,
   SkuVariants,
   ShippingSLA,
+  UserOrder,
   ObjectOrString,
   Query,
   Mutation,
@@ -105,6 +108,7 @@ export const getContextFactory =
     }
     ctx.clients = getClients(options, ctx)
     ctx.loaders = getLoaders(options, ctx)
+    ctx.account = options.account
 
     return ctx
   }

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

@@ -0,0 +1,20 @@
+import type { Context } from '..'
+import type {
+  MutationCancelOrderArgs,
+  UserOrderCancel,
+} from '../../../__generated__/schema'
+import { BadRequestError } from '../../errors'
+
+export const cancelOrder = async (
+  _: any,
+  { data }: MutationCancelOrderArgs,
+  { clients: { commerce } }: Context
+): Promise<UserOrderCancel | null> => {
+  if (!data?.orderId) {
+    throw new BadRequestError('Missing orderId')
+  }
+
+  const response = await commerce.checkout.cancelOrder(data)
+
+  return { data: response?.data }
+}

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

@@ -1,3 +1,4 @@
+import { cancelOrder } from './cancelOrder'
 import { subscribeToNewsletter } from './subscribeToNewsletter'
 import { validateCart } from './validateCart'
 import { validateSession } from './validateSession'
@@ -6,4 +7,5 @@ export const Mutation = {
   validateCart,
   validateSession,
   subscribeToNewsletter,
+  cancelOrder,
 }

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

@@ -2,15 +2,17 @@ import type {
   QueryAllCollectionsArgs,
   QueryAllProductsArgs,
   QueryCollectionArgs,
+  QueryListUserOrdersArgs,
   QueryProductArgs,
+  QueryProductCountArgs,
   QueryProfileArgs,
   QueryRedirectArgs,
   QuerySearchArgs,
   QuerySellersArgs,
   QueryShippingArgs,
-  QueryProductCountArgs,
+  QueryUserOrderArgs,
 } from '../../../__generated__/schema'
-import { BadRequestError, NotFoundError } from '../../errors'
+import { BadRequestError, ForbiddenError, NotFoundError } from '../../errors'
 import type { CategoryTree } from '../clients/commerce/types/CategoryTree'
 import type { ProfileAddress } from '../clients/commerce/types/Profile'
 import type { SearchArgs } from '../clients/search'
@@ -377,4 +379,57 @@ export const Query = {
 
     return result
   },
+  userOrder: async (
+    _: unknown,
+    { orderId }: QueryUserOrderArgs,
+    ctx: Context
+  ) => {
+    const {
+      clients: { commerce },
+    } = ctx
+    if (!orderId) {
+      throw new BadRequestError('Missing orderId')
+    }
+
+    try {
+      const order = await commerce.oms.userOrder({ orderId })
+
+      if (!order) {
+        throw new NotFoundError(`No order found for id ${orderId}`)
+      }
+
+      return order
+    } catch (error) {
+      const { message } = JSON.parse((error as Error).message).error as {
+        code: string
+        message: string
+        exception: any
+      }
+
+      if (message.toLowerCase().includes('order not found')) {
+        throw new NotFoundError(`No order found for id ${orderId}`)
+      }
+
+      if (message.toLowerCase().includes('acesso negado')) {
+        throw new ForbiddenError(
+          `You are forbidden to interact with order with id ${orderId}`
+        )
+      }
+
+      throw error
+    }
+  },
+  listUserOrders: async (
+    _: unknown,
+    filters: QueryListUserOrdersArgs,
+    ctx: Context
+  ) => {
+    const {
+      clients: { commerce },
+    } = ctx
+
+    const orders = await commerce.oms.listUserOrders(filters)
+
+    return orders
+  },
 }

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

@@ -0,0 +1,205 @@
+import type { Resolver } from '..'
+import type {
+  Maybe,
+  UserOrderCustomField,
+  UserOrderDeliveryOption,
+} from '../../..'
+import type { PromiseType } from '../../../typings'
+import type { Query } from './query'
+import { getLocalizedEstimates } from './shippingSLA'
+
+type QueryUserOrder = PromiseType<ReturnType<typeof Query.userOrder>>
+
+export type Root = QueryUserOrder
+
+const deliveryChannelsMapping = {
+  ['pickup-in-point']: 'Pickup',
+  delivery: 'Delivery',
+  pickup: 'Pickup',
+  ['take-away']: 'Take away',
+  ['']: '',
+} as const
+
+export const UserOrder: Record<string, Resolver<Root>> = {
+  orderId: ({ orderId }) => orderId,
+  totals: ({ totals }) => totals,
+  items: ({ items }) => items,
+  shippingData: ({ shippingData }) => shippingData,
+  paymentData: ({ paymentData }) => paymentData,
+  deliveryOptionsData: (root) => {
+    const { shippingData, items } = root
+    const logisticsInfo = shippingData?.logisticsInfo || []
+    const addresses = shippingData?.selectedAddresses ||
+      shippingData?.availableAddresses || [shippingData?.address]
+
+    const groupedDeliveryOptions = logisticsInfo.reduce(
+      (acc, logisticsItem) => {
+        const selectedSla = logisticsItem?.selectedSla || '' // Normal / Express
+        const deliveryChannel =
+          logisticsItem?.selectedDeliveryChannel ||
+          logisticsItem?.deliveryChannel ||
+          ''
+        const deliveryCompany = logisticsItem?.deliveryCompany || '' // Correios / Fedex
+        const deliveryWindow = logisticsItem?.deliveryWindow
+        const pickupStoreInfo = logisticsItem?.pickupStoreInfo
+        const shippingEstimate = logisticsItem?.shippingEstimate || '' // 1bd
+        const friendlyShippingEstimate = logisticsItem?.shippingEstimate
+          ? getLocalizedEstimates(logisticsItem?.shippingEstimate) // e.g. transform 3bd into Up to 3 business days
+          : ''
+
+        const shippingEstimateDate = logisticsItem?.shippingEstimateDate || '' // 2023-10-02T00:00:00Z
+        const addressId = logisticsItem?.addressId || '' // 5230338247839
+
+        const itemIndex = logisticsItem?.itemIndex ?? 0
+        const item = items?.[itemIndex]
+        const seller = item?.seller || ''
+
+        const groupKey = `${selectedSla}|${deliveryChannel}|${deliveryCompany}|${seller}|${shippingEstimate}|${shippingEstimateDate}|${addressId}|${deliveryWindow?.startDateUtc}|${deliveryWindow?.endDateUtc}`
+
+        const address = addresses?.find(
+          (address) => address?.addressId === addressId
+        )
+
+        const friendlyDeliveryOptionName =
+          `${deliveryChannelsMapping[deliveryChannel as keyof typeof deliveryChannelsMapping] || ''} ${friendlyShippingEstimate} ${address?.neighborhood ? `to ${address?.neighborhood}` : ''}`.trim()
+
+        // TODO check other totals like bundleItems etc
+        const itemTotal =
+          (item?.sellingPrice ?? 0) * (item?.quantity ?? 0) + (item?.tax ?? 0)
+
+        if (!acc[groupKey]) {
+          acc[groupKey] = {
+            // static fields
+            selectedSla,
+            deliveryChannel,
+            deliveryCompany,
+            deliveryWindow,
+            shippingEstimate,
+            shippingEstimateDate,
+            seller,
+            friendlyShippingEstimate,
+            friendlyDeliveryOptionName,
+            address,
+            pickupStoreInfo,
+            // dynamic fields
+            quantityOfDifferentItems: 0,
+            total: 0,
+            items: [],
+          }
+        }
+
+        if (acc[groupKey]) {
+          acc[groupKey].items?.push({
+            id: item?.id || '',
+            name: item?.name || '',
+            quantity: item?.quantity || 0,
+            price: item?.price || 0,
+            imageUrl: item?.imageUrl || '',
+            tax: item?.tax || 0,
+            total: itemTotal,
+          })
+
+          acc[groupKey].quantityOfDifferentItems =
+            (acc[groupKey].quantityOfDifferentItems ?? 0) + 1
+          acc[groupKey].total = (acc[groupKey].total ?? 0) + itemTotal
+        }
+
+        return acc
+      },
+      {} as Record<string, UserOrderDeliveryOption>
+    )
+
+    const deliveryOptions = Object.values(groupedDeliveryOptions)
+
+    const contactInformation = shippingData?.contactInformation?.[0]
+    const contact = {
+      name:
+        `${contactInformation?.firstName ?? ''} ${contactInformation?.lastName ?? ''}`.trim() ||
+        deliveryOptions?.[0]?.address?.receiverName ||
+        '',
+      email: contactInformation?.email || '',
+      phone: contactInformation?.phone || '',
+    }
+
+    return {
+      deliveryOptions,
+      contact,
+    }
+  },
+  customFields: (root) => {
+    const customFields = root?.customData?.customFields || []
+    return Object.values(
+      customFields.reduce(
+        (
+          acc: Record<
+            string,
+            { type: string; id: string; fields: UserOrderCustomField['fields'] }
+          >,
+          entry: Maybe<UserOrderCustomField>
+        ) => {
+          const type = entry?.linkedEntity?.type || ''
+          const id = entry?.linkedEntity?.id || ''
+          const key = `${type}|${id || ''}`
+          if (!acc[key]) {
+            acc[key] = { type, id, fields: [] }
+          }
+          acc[key].fields.push(...(entry?.fields || []))
+          return acc
+        },
+        {}
+      )
+    )
+    // Example of custom fields
+    //   return [
+    //     {
+    //       type: 'item',
+    //       id: '9009169',
+    //       fields: [
+    //         {
+    //           name: 'costCenter',
+    //           value: 'CC1',
+    //           refId: 'externalId',
+    //         },
+    //       ],
+    //     },
+    //     {
+    //       type: 'item',
+    //       id: 'ECEAC03EBA2B4BBFA7E899CD4CA5121B',
+    //       fields: [
+    //         {
+    //           name: 'costCenter',
+    //           value: 'CC2',
+    //           refId: 'externalId',
+    //         },
+    //       ],
+    //     },
+    //     {
+    //       type: 'address',
+    //       id: 'work-A1',
+    //       fields: [
+    //         {
+    //           name: 'desktop',
+    //           value: 'A1',
+    //           refId: 'externalId',
+    //         },
+    //       ],
+    //     },
+    //     {
+    //       type: 'order',
+    //       id: '',
+    //       fields: [
+    //         {
+    //           name: 'poNumber',
+    //           value: '111222333',
+    //           refId: 'externalId',
+    //         },
+    //         {
+    //           name: 'release',
+    //           value: '123',
+    //           refId: 'externalId',
+    //         },
+    //       ],
+    //     },
+    //   ]
+  },
+}