@infrab4a/connect 5.7.2 → 5.7.3

package/src/infra/mercado-pago/adapters/mercado-pago-boleto-payment-axios.adapter.ts

@@ -0,0 +1,63 @@
+import axios, { AxiosError } from 'axios'
+
+import {
+  Checkout,
+  MercadoPagoCredentials,
+  Payment,
+  PaymentProviderBankSlip,
+  PaymentRepository,
+  PaymentTransaction,
+  TransactionPaymentMethods,
+} from '../../../domain'
+import { ErrorsCode, PaymentError } from '../../../errors'
+import { MercadoPagoRequestHelper, MercadoPagoResponseHelper } from '../helpers'
+import { MercadoPagoResponse } from '../types'
+
+export class MercadoPagoBankSlipAxiosAdapter implements PaymentProviderBankSlip {
+  constructor(private credentials: MercadoPagoCredentials, private paymentRepository: PaymentRepository) {}
+
+  async pay(checkout: Checkout): Promise<Payment> {
+    try {
+      const payload = MercadoPagoRequestHelper.build({
+        checkout,
+        method: 'boleto',
+        postback: this.credentials.postback,
+      })
+
+      console.warn('[MERCADO PAGO BOLETO DATA TO SEND]', JSON.stringify(payload))
+
+      const { data }: { data: MercadoPagoResponse } = await axios({
+        method: 'POST',
+        url: `${this.credentials.url}/v1/payments`,
+        headers: {
+          'X-Idempotency-Key': `${checkout.id}-${new Date().getTime()}`,
+          Authorization: `Bearer ${this.credentials.api_key}`,
+          'Content-Type': 'application/json',
+        },
+        data: payload,
+      })
+
+      console.warn('[MERCADO PAGO RESPONSE BOLETO DATA]', JSON.stringify(data))
+
+      const payment = await this.paymentRepository.create(
+        MercadoPagoResponseHelper.build(TransactionPaymentMethods.BANKSLIP, checkout, data),
+      )
+
+      return payment
+    } catch (error) {
+      if (error instanceof AxiosError) {
+        console.warn(JSON.stringify(error.response.data.message))
+      }
+
+      throw new PaymentError('Houve uma falha ao gerar o boleto. Tente novamente', ErrorsCode.paymentError, {
+        checkoutId: checkout.id,
+        userEmail: checkout.user.email,
+        info: (error as any).response.data?.message || (error as any).message?.toString(),
+      })
+    }
+  }
+
+  getBoletoTransaction(paymentId: number): Promise<PaymentTransaction> {
+    throw new Error('Method not implemented.')
+  }
+}

package/src/infra/mercado-pago/adapters/mercado-pago-card-payment-axios.adapter.ts

@@ -0,0 +1,196 @@
+import axios, { AxiosError } from 'axios'
+
+import { MercadoPagoStatusEnum } from '../..'
+import {
+  BusinessUnitEnum,
+  CardInfo,
+  Checkout,
+  MercadoPagoCard,
+  MercadoPagoCardTokenResponse,
+  MercadoPagoCredentials,
+  OrderBlockedRepository,
+  Payment,
+  PaymentCardInfo,
+  PaymentProviderCard,
+  PaymentProviders,
+  PaymentRepository,
+  PaymentTransaction,
+  Shops,
+  TransactionPaymentMethods,
+  User,
+  UserAddress,
+} from '../../../domain'
+import { ErrorsCode, PaymentError } from '../../../errors'
+import { MercadoPagoErrorHelper, MercadoPagoRequestHelper, MercadoPagoResponseHelper } from '../helpers'
+import { MercadoPagoResponse } from '../types'
+
+import { MercadoPagoBaseAxiosAdapter } from './mercado-pago-base-axios'
+
+export class MercadoPagoCardAxiosAdapter
+  extends MercadoPagoBaseAxiosAdapter
+  implements PaymentProviderCard<MercadoPagoCard>
+{
+  constructor(
+    protected override credentials: MercadoPagoCredentials,
+    protected override paymentRepository: PaymentRepository,
+    protected orderBlockedRepository: OrderBlockedRepository,
+  ) {
+    super(credentials, paymentRepository)
+  }
+
+  async pay(checkout: Checkout, card: PaymentCardInfo): Promise<Payment> {
+    try {
+      const payload = await this.getPaymentPayload(checkout, card)
+
+      console.warn('[MERCADO PAGO CARD DATA TO SEND]', JSON.stringify(payload))
+
+      const data = await this.requestPayment(checkout, payload)
+
+      console.warn('[MERCADO PAGO RESPONSE CARD DATA]', JSON.stringify(data))
+
+      if (data.status == MercadoPagoStatusEnum.rejected) {
+        await this.orderBlockedRepository.createBlockedOrderOrPayment({
+          checkout,
+          blockType: 'Card not authorized',
+          type: 'Card',
+          limiteRange: 'day',
+          card,
+          gatewayInfo: {
+            gateway: PaymentProviders.MERCADOPAGO,
+            status: data.status,
+            statusDetail: data.status_detail,
+          },
+        })
+
+        const errorCode = MercadoPagoErrorHelper.getErrorTypeFromResponse(data.status_detail)
+
+        throw new PaymentError(
+          'Seu pagamento com cartão não foi autorizado. Para não perder seus produtos, pague com PIX ou outro cartão de crédito',
+          errorCode,
+          {
+            checkoutId: checkout.id,
+            userEmail: checkout.user.email,
+            info: data,
+          },
+        )
+      }
+
+      const payment = await this.paymentRepository.create(
+        MercadoPagoResponseHelper.build(TransactionPaymentMethods.CARD, checkout, data),
+      )
+
+      return payment
+    } catch (error) {
+      if (error instanceof AxiosError) {
+        console.warn(JSON.stringify(error.response?.data?.message))
+
+        throw new PaymentError(
+          'Seu pagamento com cartão não foi autorizado. Para não perder seus produtos, pague com PIX ou outro cartão de crédito',
+          ErrorsCode.paymentError,
+          {
+            checkoutId: checkout.id,
+            userEmail: checkout.user.email,
+            info: (error as any).response?.data?.message || (error as any).message?.toString(),
+          },
+        )
+      }
+
+      throw error
+    }
+  }
+
+  async requestPayment(checkout: Checkout, payload: any) {
+    const { data }: { data: MercadoPagoResponse } = await axios({
+      method: 'POST',
+      url: `${this.credentials.url}/v1/payments`,
+      headers: {
+        'X-Idempotency-Key': `${checkout.id}-${new Date().getTime()}`,
+        Authorization: `Bearer ${this.credentials.api_key}`,
+        'Content-Type': 'application/json',
+      },
+      data: payload,
+    })
+
+    return data
+  }
+
+  private async getPaymentPayload(checkout: Checkout, card: PaymentCardInfo) {
+    const cardResponse = await this.getCardByToken(card.customerId, card.cardId, card.cardCvv)
+    const payload = MercadoPagoRequestHelper.build({
+      checkout,
+      method: 'credit_card',
+      postback: this.credentials.postback,
+      card: {
+        ...card,
+        cardId: cardResponse.id,
+      },
+    })
+
+    return payload
+  }
+
+  async addCard?(card: CardInfo, customer: User & { billingAddress: Partial<UserAddress> }): Promise<MercadoPagoCard> {
+    return
+  }
+
+  async getCardByToken(token: string): Promise<MercadoPagoCardTokenResponse>
+  async getCardByToken(customerId: string, token: string, cardCvv: string): Promise<MercadoPagoCardTokenResponse>
+  async getCardByToken(customerId: unknown, token?: unknown, cardCvv?: unknown): Promise<MercadoPagoCardTokenResponse> {
+    try {
+      const payload = { cardId: token, customerId: customerId, securityCode: cardCvv }
+
+      console.warn('payload getCardByToken', payload)
+      const { data }: { data: MercadoPagoCardTokenResponse } = await axios({
+        method: 'POST',
+        url: `${this.credentials.url}/v1/card_tokens`,
+        headers: {
+          Authorization: `Bearer ${this.credentials.api_key}`,
+          'Content-Type': 'application/json',
+        },
+        data: payload,
+      })
+
+      return data
+    } catch (error) {
+      if (error instanceof AxiosError) {
+        console.warn(JSON.stringify(error.response.data.cause))
+      }
+
+      throw error
+    }
+  }
+
+  createCardHash<T>(bu: BusinessUnitEnum, shop: Shops, card?: CardInfo): Promise<string | T> {
+    return
+  }
+
+  createTransaction(info: any): Promise<PaymentTransaction> {
+    return
+  }
+
+  async createOrUpdateCustomer?(customer: User & { billingAddress: Partial<UserAddress> }) {
+    const { data }: { data: MercadoPagoResponse } = await axios({
+      method: 'POST',
+      url: `${this.credentials.url}/v1/customers`,
+      headers: {
+        Authorization: `Bearer ${this.credentials.api_key}`,
+        'Content-Type': 'application/json',
+      },
+      data: {
+        email: customer.email,
+        first_name: customer.firstName,
+        last_name: customer.lastName,
+        phone: {
+          area_code: customer.phone.substring(0, 2),
+          number: customer.phone.substring(2),
+        },
+        identification: {
+          type: 'CPF',
+          number: customer.cpf.replace(/\D/g, ''),
+        },
+      },
+    })
+
+    return data
+  }
+}

package/src/infra/mercado-pago/adapters/mercado-pago-pix-payment-axios.adapter.ts

@@ -0,0 +1,65 @@
+import axios, { AxiosError } from 'axios'
+
+import {
+  Checkout,
+  MercadoPagoCredentials,
+  Payment,
+  PaymentProviderPix,
+  PaymentRepository,
+  TransactionPaymentMethods,
+} from '../../../domain'
+import { ErrorsCode, PaymentError } from '../../../errors'
+import { MercadoPagoRequestHelper, MercadoPagoResponseHelper } from '../helpers'
+import { MercadoPagoResponse } from '../types'
+
+import { MercadoPagoBaseAxiosAdapter } from './mercado-pago-base-axios'
+
+export class MercadoPagoPixAxiosAdapter extends MercadoPagoBaseAxiosAdapter implements PaymentProviderPix {
+  constructor(
+    protected override credentials: MercadoPagoCredentials,
+    protected override paymentRepository: PaymentRepository,
+  ) {
+    super(credentials, paymentRepository)
+  }
+
+  async pay(checkout: Checkout): Promise<Payment> {
+    try {
+      const payload = MercadoPagoRequestHelper.build({
+        checkout,
+        method: 'pix',
+        postback: this.credentials.postback,
+      })
+
+      console.warn('[MERCADO PAGO PIX DATA TO SEND]', JSON.stringify(payload))
+
+      const { data }: { data: MercadoPagoResponse } = await axios({
+        method: 'POST',
+        url: `${this.credentials.url}/v1/payments`,
+        headers: {
+          'X-Idempotency-Key': `${checkout.id}-${new Date().getTime()}`,
+          Authorization: `Bearer ${this.credentials.api_key}`,
+          'Content-Type': 'application/json',
+        },
+        data: payload,
+      })
+
+      console.warn('[MERCADO PAGO RESPONSE PIX DATA]', JSON.stringify(data))
+
+      const payment = await this.paymentRepository.create(
+        MercadoPagoResponseHelper.build(TransactionPaymentMethods.PIX, checkout, data),
+      )
+
+      return payment
+    } catch (error) {
+      if (error instanceof AxiosError) {
+        console.warn(JSON.stringify(error.response.data.message))
+      }
+
+      throw new PaymentError('Houve uma falha ao processar pagamento com pix', ErrorsCode.paymentError, {
+        checkoutId: checkout.id,
+        userEmail: checkout.user.email,
+        info: (error as any).response.data?.message || (error as any).message?.toString(),
+      })
+    }
+  }
+}

package/src/infra/mercado-pago/enums/index.ts

@@ -0,0 +1,2 @@
+export * from './mercado-pago-status-detail.enum'
+export * from './mercado-pago-status.enum'

package/src/infra/mercado-pago/enums/mercado-pago-status-detail.enum.ts

@@ -0,0 +1,33 @@
+export enum MercadoPagoStatusDetailEnum {
+  'accredited' = 'accredited',
+  'partially_refunded' = 'partially_refunded',
+  'pending_capture' = 'pending_capture',
+  'offline_process' = 'offline_process',
+  'pending_contingency' = 'pending_contingency',
+  'pending_review_manual' = 'pending_review_manual',
+  'pending_waiting_transfer' = 'pending_waiting_transfer',
+  'pending_waiting_payment' = 'pending_waiting_payment',
+  'pending_challenge' = 'pending_challenge',
+  'bank_error' = 'bank_error',
+  'cc_rejected_3ds_mandatory' = 'cc_rejected_3ds_mandatory',
+  'cc_rejected_bad_filled_card_number' = 'cc_rejected_bad_filled_card_number',
+  'cc_rejected_bad_filled_date' = 'cc_rejected_bad_filled_date',
+  'cc_rejected_bad_filled_other' = 'cc_rejected_bad_filled_other',
+  'cc_rejected_bad_filled_security_code' = 'cc_rejected_bad_filled_security_code',
+  'cc_rejected_blacklist' = 'cc_rejected_blacklist',
+  'cc_rejected_call_for_authorize' = 'cc_rejected_call_for_authorize',
+  'cc_rejected_card_disabled' = 'cc_rejected_card_disabled',
+  'cc_rejected_card_error' = 'cc_rejected_card_error',
+  'cc_rejected_duplicated_payment' = 'cc_rejected_duplicated_payment',
+  'cc_rejected_high_risk' = 'cc_rejected_high_risk',
+  'cc_rejected_insufficient_amount' = 'cc_rejected_insufficient_amount',
+  'cc_rejected_invalid_installments' = 'cc_rejected_invalid_installments',
+  'cc_rejected_max_attempts' = 'cc_rejected_max_attempts',
+  'cc_rejected_other_reason' = 'cc_rejected_other_reason',
+  'cc_amount_rate_limit_exceeded' = 'cc_amount_rate_limit_exceeded',
+  'rejected_insufficient_data' = 'rejected_insufficient_data',
+  'rejected_by_bank' = 'rejected_by_bank',
+  'rejected_by_regulations' = 'rejected_by_regulations',
+  'insufficient_amount' = 'insufficient_amount',
+  'cc_rejected_card_type_not_allowed' = 'cc_rejected_card_type_not_allowed',
+}

package/src/infra/mercado-pago/enums/mercado-pago-status.enum.ts

@@ -0,0 +1,10 @@
+export enum MercadoPagoStatusEnum {
+  'approved' = 'approved',
+  'authorized' = 'authorized',
+  'pending' = 'pending',
+  'in_process' = 'in_process',
+  'rejected' = 'rejected',
+  'cancelled' = 'cancelled',
+  'refunded' = 'refunded',
+  'charged_back' = 'charged_back',
+}

package/src/infra/mercado-pago/helpers/index.ts

@@ -0,0 +1,3 @@
+export * from './mercado-pago-errors.helper'
+export * from './mercado-pago-request.helper'
+export * from './mercado-pago-response.helper'

package/src/infra/mercado-pago/helpers/mercado-pago-errors.helper.ts

@@ -0,0 +1,44 @@
+import { ErrorsCode } from '../../../errors'
+
+export class MercadoPagoErrorHelper {
+  static getErrorTypeFromResponse(errorCode: string): string {
+    switch (errorCode) {
+      case 'bad_filled_card_data':
+      case 'invalid_card_token':
+      case 'card_disabled':
+      case 'cc_rejected_card_disabled':
+      case 'cc_rejected_bad_filled_card_number':
+      case 'cc_rejected_bad_filled_date':
+      case 'cc_rejected_bad_filled_other':
+      case 'cc_rejected_bad_filled_security_code':
+        return ErrorsCode.invalidCardError
+      case 'high_risk':
+      case 'rejected_high_risk':
+      case 'cc_rejected_blacklist':
+      case 'cc_rejected_call_for_authorize':
+      case 'cc_rejected_high_risk':
+        return ErrorsCode.fraudPreventionExternal
+
+      case 'rejected_by_issuer':
+      case 'rejected_by_bank':
+      case 'cc_rejected_max_attempts':
+      case 'required_call_for_authorize':
+      case 'max_attempts_exceeded':
+        return ErrorsCode.paymentNotAuthorizedError
+
+      case 'insufficient_amount':
+      case 'amount_limit_exceeded':
+      case 'cc_rejected_insufficient_amount':
+        return ErrorsCode.insufficientFundsError
+      case 'processing_error':
+        return ErrorsCode.paymentError
+      case 'invalid_installments':
+      case 'cc_rejected_invalid_installments':
+      case 'cc_rejected_other_reason':
+      case 'rejected_insufficient_data':
+        return ErrorsCode.businessError
+      default:
+        return ErrorsCode.paymentError
+    }
+  }
+}

package/src/infra/mercado-pago/helpers/mercado-pago-request.helper.ts

@@ -0,0 +1,121 @@
+import { Checkout, PaymentCardInfo, Shops } from '../../../domain'
+import { addDays, addHours, format } from '../../../utils'
+
+export class MercadoPagoRequestHelper {
+  static build(data: {
+    checkout: Checkout
+    method: 'pix' | 'boleto' | 'credit_card'
+    postback: string
+    card?: PaymentCardInfo
+  }) {
+    const { checkout, method, postback, card } = data
+
+    return {
+      transaction_amount: +checkout.totalPrice.toFixed(2),
+      notification_url: postback,
+      metadata: {
+        checkoutId: checkout.id,
+      },
+      payer: this.buildPayer(checkout, card),
+      statement_descriptor: checkout.shop === Shops.GLAMSHOP ? 'loja glam' : 'mens market',
+      additional_info: {
+        items: this.buildItems(checkout),
+      },
+      ...(method === 'credit_card' && this.buildCardPayment(card)),
+      ...(method === 'pix' && this.buildPixPayment()),
+      ...(method === 'boleto' && this.buildBoletoPayment(checkout)),
+    }
+  }
+
+  private static buildItems(checkout: Checkout) {
+    return checkout.lineItems
+      .filter((item) => !item.isGift)
+      .map((item) => {
+        return {
+          id: item.EAN,
+          title: item.name,
+          description: item.name,
+          picture_url: item.image ?? null,
+          category_id: item.category?.id ?? null,
+          quantity: item.quantity,
+          unit_price: +item.pricePaid.toFixed(2),
+        }
+      })
+  }
+
+  private static buildPayer(checkout: Checkout, card?: PaymentCardInfo) {
+    return {
+      ...(card && { id: card.customerId }),
+      first_name: checkout.user.firstName,
+      last_name: checkout.user.lastName,
+      email: checkout.user.email,
+      identification: {
+        type: 'CPF',
+        number: checkout.user.cpf.replace(/\D/g, ''),
+      },
+    }
+  }
+
+  private static buildFullPayer(checkout: Checkout) {
+    return {
+      first_name: checkout.user.firstName,
+      last_name: checkout.user.lastName,
+      phone: {
+        area_code: checkout.user.phone.substring(0, 2),
+        number: checkout.user.phone.substring(2),
+      },
+      address: {
+        zip_code: checkout.shippingAddress.zip,
+        street_name: `${checkout.shippingAddress.street}, ${checkout.shippingAddress.district}`,
+        street_number: checkout.shippingAddress.number,
+        neighborhood: checkout.shippingAddress.district,
+        city: checkout.shippingAddress.city,
+        federal_unit: checkout.shippingAddress.state,
+      },
+    }
+  }
+
+  private static buildCardPayment(card) {
+    return {
+      installments: card.installments,
+      token: card.cardId,
+      binary_mode: true,
+      capture: true,
+    }
+  }
+
+  private static buildPixPayment() {
+    return {
+      payment_method_id: 'pix',
+      date_of_expiration: format(addHours(new Date(), 24), "yyyy-MM-dd'T'HH:mm:ss.SSSxxx"),
+    }
+  }
+
+  private static buildBoletoPayment(checkout: Checkout) {
+    return {
+      payment_method_id: 'bolbradesco',
+      date_of_expiration: format(addDays(new Date(), 3), 'yyyy-MM-dd') + 'T23:59:59.999-03:00',
+      payer: {
+        first_name: checkout.user.firstName,
+        last_name: checkout.user.lastName,
+        email: checkout.user.email,
+        identification: {
+          type: 'CPF',
+          number: checkout.user.cpf.replace(/\D/g, ''),
+        },
+        phone: {
+          area_code: checkout.user.phone.substring(0, 2),
+          number: checkout.user.phone.substring(2),
+        },
+        address: {
+          zip_code: checkout.shippingAddress.zip.replace(/\D/g, ''),
+          street_name: `${checkout.shippingAddress.street}, ${checkout.shippingAddress.district}`,
+          street_number: checkout.shippingAddress.number,
+          neighborhood: checkout.shippingAddress.district,
+          city: checkout.shippingAddress.city,
+          federal_unit: checkout.shippingAddress.state,
+        },
+      },
+    }
+  }
+}

package/src/infra/mercado-pago/helpers/mercado-pago-response.helper.ts

@@ -0,0 +1,88 @@
+import { Checkout, Payment, PaymentProviders, PaymentTransaction, TransactionPaymentMethods } from '../../../domain'
+import { MercadoPagoResponse } from '../types'
+
+export class MercadoPagoResponseHelper {
+  static build(method: TransactionPaymentMethods, checkout: Checkout, response: MercadoPagoResponse): Payment {
+    return Payment.toInstance({
+      createdAt: new Date(),
+      updatedAt: new Date(),
+      userId: checkout.user.id,
+      checkoutId: checkout.id,
+      totalPrice: checkout.totalPrice,
+      paymentProvider: PaymentProviders.MERCADOPAGO,
+      mercadoPagoId: response.id,
+      transaction: this.buildPaymentTransaction(method, response),
+    })
+  }
+
+  private static buildPaymentTransaction(
+    method: TransactionPaymentMethods,
+    response: MercadoPagoResponse,
+  ): PaymentTransaction {
+    return PaymentTransaction.toInstance({
+      id: response.id.toString(),
+      acquirer_name: PaymentProviders.MERCADOPAGO,
+      amount: response.transaction_amount,
+      status: this.statusMapping(response.status),
+      status_reason: response.status_detail?.toString(),
+      payment_method: method,
+      currency: response.currency_id?.toString(),
+      paid_amount: response.transaction_details?.total_paid_amount ?? null,
+      paid_at: response.date_approved ?? null,
+      charger_id: response.charges_details?.at(0)?.id?.toString() ?? null,
+      ...(method == TransactionPaymentMethods.PIX && this.getPixReponse(response)),
+      ...(method == TransactionPaymentMethods.CARD && this.getCardReponse(response)),
+      ...(method == TransactionPaymentMethods.BANKSLIP && this.getBoletoReponse(response)),
+    })
+  }
+
+  private static getBoletoReponse(response: MercadoPagoResponse): Partial<PaymentTransaction> {
+    return {
+      boleto_url: response.transaction_details?.external_resource_url?.toString(),
+      boleto_barcode: response.transaction_details?.barcode?.content?.toString(),
+      boleto_line: response.transaction_details?.digitable_line?.toString(),
+      boleto_expiration_date: response.date_of_expiration?.toString(),
+      boleto_document_number: response.transaction_details?.verification_code?.toString(),
+    }
+  }
+
+  private static getPixReponse(response: MercadoPagoResponse): Partial<PaymentTransaction> {
+    return {
+      pix_qr_code: response.point_of_interaction?.transaction_data?.qr_code,
+      pix_expiration_date: response.date_of_expiration?.toString(),
+    }
+  }
+
+  private static getCardReponse(response: MercadoPagoResponse): Partial<PaymentTransaction> {
+    return {
+      soft_descriptor: response.statement_descriptor?.toString(),
+      installments: response.installments,
+      card_brand: response.payment_method_id?.toString(),
+      card_first_digits: response.card?.first_six_digits?.toString(),
+      card_last_digits: response.card?.last_four_digits?.toString(),
+      card_id: response.card?.id?.toString(),
+      card_holder_name: response.card?.cardholder?.name?.toString(),
+      card_expiration_month: response.card?.expiration_month?.toString(),
+      card_expiration_year: response.card?.expiration_year?.toString(),
+      capture_method: response.payment_type_id?.toString(),
+      authorization_code: response.authorization_code?.toString(),
+      paid_amount:
+        this.statusMapping(response.status) == 'paid' ? response.transaction_details?.total_paid_amount : null,
+      paid_at: this.statusMapping(response.status) == 'paid' ? response.date_approved : null,
+    }
+  }
+
+  static statusMapping(status: string): string {
+    const statusMap: { [key: string]: string } = {
+      approved: 'paid',
+      pending: 'waiting_payment',
+      in_process: 'processing',
+      rejected: 'refused',
+      cancelled: 'refused',
+      refunded: 'refunded',
+      charged_back: 'chargedback',
+    }
+
+    return statusMap[status] || status
+  }
+}

package/src/infra/mercado-pago/index.ts

@@ -0,0 +1,4 @@
+export * from './adapters'
+export * from './enums'
+export * from './helpers'
+export * from './types'

package/src/infra/mercado-pago/types/index.ts

@@ -0,0 +1,3 @@
+export * from './mercado-pago-request.type'
+export * from './mercado-pago-response.type'
+export * from './mercado-pago-status.type'

package/src/infra/mercado-pago/types/mercado-pago-request.type.ts

@@ -0,0 +1 @@
+export type MercadoPagoRequest = {}