feat: my account release 2

packages/api/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'

packages/api/src/platforms/vtex/clients/commerce/Contract.ts

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

packages/api/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 }
         )
       },

packages/api/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[]
+  }>
+}

packages/api/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
+}

packages/api/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
   }

packages/api/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 }
+}