@faststore/api 3.41.8 → 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,23 +366,48 @@ 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)
 
       params.set(
         'items',
-        'profile.id,profile.email,profile.firstName,profile.lastName,store.channel,store.countryCode,store.cultureInfo,store.currencyCode,store.currencySymbol,authentication.customerId,'
+        'profile.id,profile.email,profile.firstName,profile.lastName,store.channel,store.countryCode,store.cultureInfo,store.currencyCode,store.currencySymbol,authentication.customerId,checkout.regionId,'
       )
 
       const headers: HeadersInit = withCookie({
         'content-type': 'application/json',
       })
 
+      const sessionCookie = parse(ctx?.headers?.cookie ?? '')?.vtex_session
+
       return fetchAPI(
         `${base}/api/sessions?${params.toString()}`,
         {
-          method: 'POST',
+          method: sessionCookie ? 'PATCH' : 'POST',
           headers,
           body: '{}',
         },
@@ -390,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/Address.ts

@@ -13,5 +13,5 @@ export interface Address {
   neighborhood: string
   complement: string
   reference: string
-  geoCoordinates: [number]
+  geoCoordinates: [number, number] // [longitude, latitude]
 }

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

@@ -36,6 +36,7 @@ export interface Profile {
 
 export interface Checkout {
   orderFormId?: Value
+  regionId?: Value
 }
 
 export interface Public {

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/clients/search/index.ts

@@ -16,6 +16,7 @@ import type {
   ProductSearchResult,
   Suggestion,
 } from './types/ProductSearchResult'
+import type { ProductCountResult } from './types/ProductCountResult'
 
 export type Sort =
   | 'price:desc'
@@ -265,10 +266,26 @@ export const IntelligentSearch = (
   const facets = (args: Omit<SearchArgs, 'type'>) =>
     search<FacetSearchResult>({ ...args, type: 'facets' })
 
+  const productCount = (
+    args: Pick<SearchArgs, 'query'>
+  ): Promise<ProductCountResult> => {
+    const params = new URLSearchParams()
+
+    if (args?.query) {
+      params.append('query', args.query.toString())
+    }
+
+    return fetchAPI(
+      `${base}/_v/api/intelligent-search/catalog_count?${params.toString()}`,
+      { headers }
+    )
+  }
+
   return {
     facets,
     products,
     suggestedTerms,
     topSearches,
+    productCount,
   }
 }

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

@@ -0,0 +1,6 @@
+export interface ProductCountResult {
+  /**
+   * @description Total product count.
+   */
+  total: number
+}

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,14 +2,17 @@ import type {
   QueryAllCollectionsArgs,
   QueryAllProductsArgs,
   QueryCollectionArgs,
+  QueryListUserOrdersArgs,
   QueryProductArgs,
+  QueryProductCountArgs,
   QueryProfileArgs,
   QueryRedirectArgs,
   QuerySearchArgs,
   QuerySellersArgs,
   QueryShippingArgs,
+  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'
@@ -361,4 +364,72 @@ export const Query = {
 
     return { addresses: parsedAddresses }
   },
+  productCount: async (
+    _: unknown,
+    { term }: QueryProductCountArgs,
+    ctx: Context
+  ) => {
+    const {
+      clients: { search },
+    } = ctx
+
+    const result = await search.productCount({
+      query: term ?? undefined,
+    })
+
+    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
+  },
 }