@infrab4a/connect 5.0.0-alpha.9 → 6.0.0-alpha.0

package/src/infra/pagarme/adapters/index.ts

@@ -0,0 +1,3 @@
+export * from './pagarme-bank-slip-payment-axios.adapter'
+export * from './pagarme-card-payment-axios.adapter'
+export * from './pagarme-pix-payment-axios.adapter'

package/src/infra/pagarme/adapters/pagarme-bank-slip-payment-axios.adapter.ts

@@ -0,0 +1,97 @@
+import axios from 'axios'
+
+import { PagarmePaymentStatus } from '../../../domain/shopping/enums'
+import { PaymentProviderBankSlip } from '../../../domain/shopping/interfaces'
+import { Checkout, Payment, PaymentTransaction } from '../../../domain/shopping/models'
+import { PaymentRepository } from '../../../domain/shopping/repositories'
+import { PagarmeCredentials } from '../../../domain/shopping/types'
+import { BusinessError, PaymentError } from '../../../errors'
+import { addDays, format } from '../../../utils'
+
+export class PagarmeBankSlipAxiosAdapter implements PaymentProviderBankSlip {
+  constructor(private credentials: PagarmeCredentials, private paymentRepository: PaymentRepository) {}
+
+  async pay(checkout: Checkout): Promise<Payment> {
+    try {
+      const payload = this.createBoletoPayment(checkout)
+      const result = await axios({
+        method: 'POST',
+        url: `${this.credentials.URL}/transactions`,
+        data: this.createBoletoPayment(checkout),
+      })
+
+      console.warn('[PAGARME BOLETO DATA TO SEND]', payload)
+
+      if (result.data.status !== PagarmePaymentStatus['Em processamento']) {
+        return Promise.reject(
+          new PaymentError('Houve uma falha ao gerar o boleto. Tente novamente', {
+            checkoutId: checkout.id,
+            userEmail: checkout.user.email,
+            info: result.data,
+          }),
+        )
+      }
+
+      const payment = await this.paymentRepository.create({
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        userId: checkout.user.id,
+        checkoutId: checkout.id,
+        totalPrice: checkout.totalPrice,
+        paymentProvider: 'pagarMe',
+        transaction: result.data,
+      })
+
+      return payment
+    } catch (error: any) {
+      throw new PaymentError('Houve uma falha ao gerar o boleto. Tente novamente', {
+        checkoutId: checkout.id,
+        userEmail: checkout.user.email,
+        info: error.response.data,
+      })
+    }
+  }
+
+  async getBoletoTransaction(paymentId: number): Promise<PaymentTransaction> {
+    try {
+      const { data }: { data: PaymentTransaction } = await axios({
+        method: 'GET',
+        url: `${this.credentials.URL}/transactions/${paymentId}`,
+        data: {
+          api_key: this.credentials.API_KEY,
+        },
+      })
+
+      return data
+    } catch (error: any) {
+      throw new BusinessError('Houve uma falha buscar o boleto com paymentId: ' + paymentId, {
+        paymentId,
+        info: error.response.data,
+      })
+    }
+  }
+
+  private createBoletoPayment(checkout: Checkout) {
+    return {
+      api_key: this.credentials.API_KEY,
+      amount: Math.floor(checkout.totalPrice * 100),
+      boleto_rules: ['strict_expiration_date'],
+      boleto_instructions: 'Sr. Caixa, NÃO aceitar o pagamento após o vencimento.',
+      boleto_expiration_date: format(addDays(new Date(), 3), 'yyyy-MM-dd'),
+      payment_method: 'boleto',
+      postback_url: this.credentials.URL_POSTBACK,
+      customer: {
+        external_id: checkout.user.id,
+        type: 'individual',
+        country: 'br',
+        name: checkout.user.displayName,
+        documents: [
+          {
+            type: 'cpf',
+            number: checkout.user.cpf,
+          },
+        ],
+      },
+    }
+  }
+}

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

@@ -0,0 +1,183 @@
+import axios from 'axios'
+
+import { Shops } from '../../../domain/catalog'
+import { BusinessUnitEnum, PagarmePaymentStatus } from '../../../domain/shopping/enums'
+import { PaymentProviderCard } from '../../../domain/shopping/interfaces'
+import { Checkout, LineItem, Payment, PaymentTransaction } from '../../../domain/shopping/models'
+import { OrderBlockedRepository, PaymentRepository } from '../../../domain/shopping/repositories'
+import { CardInfo, PagarMeCard, PagarmeCredentials, PaymentCardInfo } from '../../../domain/shopping/types'
+import { BusinessError, PaymentError } from '../../../errors'
+
+import { PagarmeBlockedOrderHelper, PagarmePaymentFactoryHelper, PagarmePaymentOperationsHelper } from './helpers'
+
+export class PagarmeCardAxiosAdapter implements PaymentProviderCard<PagarMeCard> {
+  constructor(
+    private credentials: PagarmeCredentials,
+    private paymentRepository: PaymentRepository,
+    private orderBlockedRepository: OrderBlockedRepository,
+  ) {}
+
+  async pay(checkout: Checkout, card: PaymentCardInfo): Promise<Payment> {
+    try {
+      const result = await PagarmePaymentOperationsHelper.executePaymentRequest({
+        checkout,
+        card,
+        credentials: this.credentials,
+        createPayloadFunction: this.createCardPayment.bind(this),
+      })
+
+      if (result.data.status !== PagarmePaymentStatus.Pago) {
+        await PagarmeBlockedOrderHelper.createBlockedOrderForUnauthorizedCard({
+          checkout,
+          card,
+          orderBlockedRepository: this.orderBlockedRepository,
+        })
+
+        throw PagarmeBlockedOrderHelper.createPaymentError(checkout, result.data)
+      }
+
+      return PagarmePaymentFactoryHelper.createSuccessfulPayment({
+        checkout,
+        resultData: result.data,
+        paymentRepository: this.paymentRepository,
+      })
+    } catch (error: any) {
+      if (error instanceof PaymentError) {
+        throw error
+      }
+
+      throw PagarmeBlockedOrderHelper.createGenericPaymentError(checkout, error.response?.data)
+    }
+  }
+
+  async addCard(card: CardInfo): Promise<PagarMeCard> {
+    try {
+      const { data }: { data: PagarMeCard } = await axios({
+        method: 'POST',
+        url: `${this.credentials.URL}/cards`,
+        data: {
+          api_key: this.credentials.API_KEY,
+          card_number: card.number,
+          card_expiration_date: card.expirationDate.replace('/', ''),
+          card_holder_name: card.name,
+          card_cvv: card.cvv,
+        },
+      })
+
+      return data
+    } catch (error: any) {
+      throw new BusinessError('Houve uma falha adicionar o cartão', {
+        info: error.response.data,
+      })
+    }
+  }
+
+  async createCardHash<PagarMeCardManualHash>(bu: BusinessUnitEnum): Promise<PagarMeCardManualHash> {
+    const key = bu === BusinessUnitEnum.SHOP ? this.credentials.SHOP_API_KEY : this.credentials.SUBSCRIPTION_API_KEY
+
+    try {
+      const { data }: { data: PagarMeCardManualHash } = await axios({
+        method: 'GET',
+        headers: {
+          'content-type': 'application/json',
+        },
+        url: `${this.credentials.URL}/transactions/card_hash_key`,
+        data: JSON.stringify({
+          api_key: key,
+        }),
+      })
+
+      return data
+    } catch (error: any) {
+      throw new BusinessError('Houve uma falha gerar o hash', {
+        info: error.response.data,
+      })
+    }
+  }
+
+  async getCardByToken(id: string): Promise<PagarMeCard> {
+    try {
+      const { data }: { data: PagarMeCard } = await axios({
+        method: 'POST',
+        url: `${this.credentials.URL}/cards/${id}`,
+        data: {
+          api_key: this.credentials.API_KEY,
+        },
+      })
+
+      return data
+    } catch (error: any) {
+      throw new BusinessError('Houve uma falha buscar o cartão com id: ' + id, {
+        info: error.response.data,
+      })
+    }
+  }
+
+  async createTransaction(info: any): Promise<PaymentTransaction> {
+    try {
+      const { data }: { data: PaymentTransaction } = await axios({
+        method: 'POST',
+        url: `${this.credentials.URL}/transactions`,
+        data: {
+          ...info,
+          api_key: this.credentials.API_KEY,
+        },
+      })
+
+      return data
+    } catch (error: any) {
+      throw new BusinessError('Houve uma falha ao criar a transação', {
+        info: error.response.data,
+      })
+    }
+  }
+
+  private createCardPayment(checkout: Checkout, card: PaymentCardInfo) {
+    return {
+      api_key: this.credentials.API_KEY,
+      amount: Math.floor(checkout.totalPrice * 100),
+      card_id: card.cardId,
+      card_cvv: card.cardCvv,
+      payment_method: 'credit_card',
+      installments: card.installments,
+      soft_descriptor: checkout.shop === Shops.GLAMSHOP ? 'Glam' : "Men's Market",
+      customer: {
+        external_id: checkout.user.id,
+        name: checkout.user.displayName,
+        type: 'individual',
+        country: 'br',
+        email: checkout.user.email,
+        phone_numbers: checkout.user.phone ? ['+55' + checkout.user.phone] : '',
+        documents: [
+          {
+            type: 'cpf',
+            number: checkout.user.cpf,
+          },
+        ],
+      },
+      billing: {
+        name: checkout.user.displayName,
+        address: {
+          country: 'br',
+          state: checkout.billingAddress ? checkout.billingAddress.state : checkout.shippingAddress?.state,
+          city: checkout.billingAddress ? checkout.billingAddress.city : checkout.shippingAddress?.city,
+          neighborhood: checkout.billingAddress ? checkout.billingAddress.district : checkout.shippingAddress?.district,
+          street: checkout.billingAddress ? checkout.billingAddress.street : checkout.shippingAddress?.street,
+          street_number: checkout.billingAddress ? checkout.billingAddress.number : checkout.shippingAddress?.number,
+          zipcode: checkout.billingAddress
+            ? checkout.billingAddress.zip.replace('-', '')
+            : checkout.shippingAddress?.zip.replace('-', ''),
+        },
+      },
+      items: checkout.lineItems.map((item: LineItem) => {
+        return {
+          id: item.id,
+          title: checkout.user.isSubscriber ? `${item.name} - ASSINANTE` : item.name,
+          unit_price: Math.floor(item.pricePaid * 100),
+          quantity: item.quantity,
+          tangible: true,
+        }
+      }),
+    }
+  }
+}

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

@@ -0,0 +1,67 @@
+import axios from 'axios'
+
+import { PaymentProviderPix } from '../../../domain/shopping/interfaces'
+import { Checkout, Payment } from '../../../domain/shopping/models'
+import { PaymentRepository } from '../../../domain/shopping/repositories'
+import { PagarmeCredentials } from '../../../domain/shopping/types'
+import { PaymentError } from '../../../errors'
+import { addDays, format } from '../../../utils'
+
+export class PagarmePixAxiosAdapter implements PaymentProviderPix {
+  constructor(private credentials: PagarmeCredentials, private paymentRepository: PaymentRepository) {}
+
+  public async pay(checkout: Checkout): Promise<Payment> {
+    try {
+      const payload = this.createPixPayment(checkout)
+      const result = await axios({
+        method: 'POST',
+        url: `${this.credentials.URL}/transactions`,
+        data: payload,
+      })
+
+      console.warn('[PAGARME PIX DATA TO SEND]', payload)
+
+      const payment = await this.paymentRepository.create({
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        userId: checkout.user.id,
+        checkoutId: checkout.id,
+        totalPrice: checkout.totalPrice,
+        paymentProvider: 'pagarMe',
+        transaction: result.data,
+      })
+
+      return payment
+    } catch (error: any) {
+      throw new PaymentError('Houve uma falha ao processar pagamento com pix', {
+        checkoutId: checkout.id,
+        userEmail: checkout.user.email,
+        info: error.response?.data,
+      })
+    }
+  }
+
+  private createPixPayment(checkout: Checkout) {
+    return {
+      payment_method: 'pix',
+      amount: Math.floor(checkout.totalPrice * 100),
+      api_key: this.credentials.API_KEY,
+      postback_url: this.credentials.URL_POSTBACK,
+      pix_expiration_date: format(addDays(new Date(), 1), 'yyyy-MM-dd'),
+      customer: {
+        external_id: checkout.user.id,
+        type: 'individual',
+        country: 'br',
+        name: checkout.user.displayName,
+        email: checkout.user.email.trim(),
+        phone_numbers: checkout.user.phone ? ['+55' + checkout.user.phone] : '',
+        documents: [
+          {
+            type: 'cpf',
+            number: checkout.user.cpf,
+          },
+        ],
+      },
+    }
+  }
+}

package/src/infra/pagarme/index.ts

@@ -0,0 +1 @@
+export * from './adapters'

package/src/infra/vertex-ai/adapters/index.ts

@@ -0,0 +1,2 @@
+export * from './vertex-ai-search.adapter'
+export * from './vertex-axios.adapter'

package/src/infra/vertex-ai/adapters/vertex-ai-search.adapter.ts

@@ -0,0 +1,11 @@
+import { Product } from '../../../domain'
+import { ProductBulk } from '../types'
+
+export interface VertexSearchAdapter<T> {
+  query(searchTerm: string, total: number, gender?: String): Promise<T[]>
+  get(id: string): Promise<T>
+  save(data: Product): Promise<any>
+  update(id: string, data: Product): Promise<any>
+  delete(id: string): Promise<void>
+  bulkProducts(products: ProductBulk[]): Promise<void>
+}

package/src/infra/vertex-ai/adapters/vertex-axios.adapter.ts

@@ -0,0 +1,133 @@
+import axios, { AxiosRequestConfig } from 'axios'
+
+import { Product } from '../../../domain'
+import { DebugHelper } from '../../../utils'
+import { ProductBulk, ProductSearch } from '../types'
+import { VertexSearchConfig } from '../types/axios-vertex-search-config'
+
+import { VertexSearchAdapter } from './vertex-ai-search.adapter'
+
+export class VertexAxiosAdapter implements VertexSearchAdapter<ProductSearch> {
+  private logger: DebugHelper
+
+  constructor(private readonly config: VertexSearchConfig) {
+    this.logger = DebugHelper.from(this)
+  }
+
+  async query(term: string, total: number, gender?: String): Promise<ProductSearch[]> {
+    const logger = this.logger.with('query')
+    const req: AxiosRequestConfig = {
+      url: `${this.config.url}/search`,
+      method: 'POST',
+      responseType: 'json',
+      headers: {
+        Accept: 'application/json',
+      },
+      data: { term, total, gender },
+    }
+
+    try {
+      const { data }: { data: ProductSearch[] } = await axios(req)
+
+      return data
+    } catch (error) {
+      logger.error({ req, res: error })
+
+      throw error
+    }
+  }
+
+  async get(id: string): Promise<ProductSearch> {
+    const logger = this.logger.with('update')
+    const req: AxiosRequestConfig = {
+      url: `${this.config.url}/${id}`,
+      method: 'GET',
+      responseType: 'json',
+      headers: {
+        Accept: 'application/json',
+      },
+    }
+
+    try {
+      const { data } = await axios(req)
+
+      return data
+    } catch (error) {
+      logger.error({ req, res: error })
+
+      throw error
+    }
+  }
+
+  async save(data: Product) {
+    const logger = this.logger.with('save')
+    const req: AxiosRequestConfig = {
+      url: `${this.config.url}/sync`,
+      method: 'POST',
+      responseType: 'json',
+      headers: {
+        Accept: 'application/json',
+      },
+      data,
+    }
+
+    try {
+      const { data } = await axios(req)
+
+      return data
+    } catch (error) {
+      logger.error({ req, res: error })
+
+      throw error
+    }
+  }
+
+  async update(id: string, data: Product) {
+    const logger = this.logger.with('update')
+    const req: AxiosRequestConfig = {
+      url: `${this.config.url}/${id}`,
+      method: 'PUT',
+      responseType: 'json',
+      headers: {
+        Accept: 'application/json',
+      },
+      data,
+    }
+
+    try {
+      const { data } = await axios(req)
+
+      return data
+    } catch (error) {
+      logger.error({ req, res: error })
+
+      throw error
+    }
+  }
+
+  async delete(id: string): Promise<void> {
+    const logger = this.logger.with('delete')
+    const req: AxiosRequestConfig = {
+      url: `${this.config.url}/${id}`,
+      method: 'DELETE',
+      responseType: 'json',
+      headers: {
+        Accept: 'application/json',
+      },
+    }
+
+    try {
+      const { data } = await axios(req)
+
+      return data
+    } catch (error) {
+      logger.error({ req, res: error })
+
+      throw error
+    }
+  }
+
+  bulkProducts(_products: ProductBulk[]): Promise<void> {
+    return
+  }
+}

package/src/infra/vertex-ai/index.ts

@@ -0,0 +1,3 @@
+export * from './adapters'
+export * from './indexes'
+export * from './types'

package/src/infra/vertex-ai/indexes/index.ts

@@ -0,0 +1 @@
+export * from './products-vertex-search'

package/src/infra/vertex-ai/indexes/products-vertex-search.ts

@@ -0,0 +1,52 @@
+import { Product, ProductSearchIndex } from '../../../domain'
+import { omit } from '../../../utils'
+import { ProductHasuraGraphQL } from '../../hasura-graphql'
+import { VertexSearchAdapter } from '../adapters'
+import { ProductSearch } from '../types'
+
+export class ProductsVertexSearch implements ProductSearchIndex {
+  constructor(private readonly adapter: VertexSearchAdapter<ProductSearch>) {}
+
+  async getById(id: string): Promise<ProductSearch> {
+    const data = await this.adapter.get(id)
+
+    return data
+  }
+
+  async search<ProductSearch>(searchTerm: string, total: number, gender?: String): Promise<ProductSearch[]> {
+    try {
+      const result = await this.adapter.query(searchTerm, total, gender)
+
+      return result as ProductSearch[]
+    } catch (error) {
+      console.error(error)
+    }
+  }
+
+  async save(product: ProductHasuraGraphQL): Promise<void> {
+    try {
+      const data = omit(product.toPlain(), ['createdAt', 'updatedAt', 'kitProducts'])
+      const newProduct = Product.toInstance(data)
+
+      await this.adapter.save(newProduct)
+    } catch (error) {
+      console.error(error)
+    }
+  }
+
+  async update(product: ProductHasuraGraphQL) {
+    try {
+      await this.adapter.update(product.id, product)
+    } catch (error) {
+      console.error(error)
+    }
+  }
+
+  async delete(id: string): Promise<void> {
+    try {
+      await this.adapter.delete(id)
+    } catch (error) {
+      console.error(error)
+    }
+  }
+}

package/src/infra/vertex-ai/types/axios-vertex-search-config.ts

@@ -0,0 +1,4 @@
+export type VertexSearchConfig = {
+  url: string
+  token?: string
+}

package/src/infra/vertex-ai/types/index.ts

@@ -0,0 +1,3 @@
+export * from './axios-vertex-search-config'
+export * from './product-bulk'
+export * from './product-search'

package/src/infra/vertex-ai/types/product-bulk.ts

@@ -0,0 +1,4 @@
+export type ProductBulk = {
+  id: string
+  jsonData: string
+}

package/src/infra/vertex-ai/types/product-search.ts

@@ -0,0 +1,21 @@
+export type ProductSearch = {
+  id: string
+  name: string
+  ean?: string
+  sku: string
+  icon?: string
+  miniatures?: string
+  description?: string
+  slug: string
+  brand: string
+  published: boolean
+  gender: string
+  shoppingCount: number
+  stock: number
+  rating: number
+  fullPrice: number
+  price: number
+  subscriberPrice: number
+  outlet: boolean
+  createdAt: Date
+}

package/src/utils/circular-dependencies.ts

@@ -0,0 +1,26 @@
+/**
+ * Este arquivo define funções para resolver dependências circulares
+ * em ambiente ESM, onde não podemos usar require()
+ */
+
+// Armazenamento global para classes registradas
+const registry = new Map<string, any>()
+
+// Registrar uma classe na resolução de dependências circulares
+export function registerClass(name: string, classConstructor: any): void {
+  registry.set(name, classConstructor)
+}
+
+// Obter uma classe registrada
+export function getClass(name: string): any {
+  return registry.get(name)
+}
+
+// Função de resolução para class-transformer
+export function resolveClass(name: string): () => any {
+  return () => {
+    // Forçamos o retorno de uma função que retorna a classe
+    // ao invés da classe diretamente para evitar problemas com o decorator
+    return getClass(name)
+  }
+}

package/src/utils/decorators/debug.class.decorator.ts

@@ -0,0 +1,7 @@
+import { DebugDecoratorHelper, DebugOptions } from '../helpers'
+
+export function Debug(opts?: DebugOptions): ClassDecorator {
+  return function <TFunction>(target: any): TFunction | void {
+    DebugDecoratorHelper.set(target.prototype, opts)
+  }
+}

package/src/utils/decorators/index.ts

@@ -0,0 +1,2 @@
+export * from './debug.class.decorator'
+export * from './trace.method.decorator'