@infrab4a/connect-nestjs 2.0.0-alpha.9 → 3.0.0-alpha.0

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

@@ -0,0 +1,96 @@
+import {
+  addDays,
+  BusinessError,
+  Checkout,
+  format,
+  PagarmeCredentials,
+  PagarmePaymentStatus,
+  Payment,
+  PaymentError,
+  PaymentProviderBankSlip,
+  PaymentRepository,
+  PaymentTransaction,
+} from '@infrab4a/connect'
+import pagarme from 'pagarme'
+
+export class PagarmeBankSlipAPIAdapter implements PaymentProviderBankSlip {
+  constructor(private credentials: PagarmeCredentials, private paymentRepository: PaymentRepository) {}
+
+  public async pay(checkout: Checkout): Promise<Payment> {
+    try {
+      const client = await pagarme.client.connect({ api_key: this.credentials.API_KEY })
+      const payload = this.createBoletoPayment(checkout)
+      const result = await client.transactions.create(payload)
+
+      console.warn('[PAGARME BOLETO DATA TO SEND]', payload)
+      console.warn('result PagarmeBankSlipAPIAdapter', JSON.stringify(result))
+
+      if (result.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,
+          }),
+        )
+      }
+
+      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,
+      })
+
+      return payment
+    } catch (error) {
+      console.error('Error PagarmeBankSlipAPIAdapter', JSON.stringify(error))
+      throw new PaymentError('Houve uma falha ao gerar o boleto. Tente novamente', {
+        checkoutId: checkout.id,
+        userEmail: checkout.user.email,
+        info: error,
+      })
+    }
+  }
+
+  public async getBoletoTransaction(paymentId: number): Promise<PaymentTransaction> {
+    try {
+      const client = await pagarme.client.connect({ api_key: this.credentials.API_KEY })
+      const result = await client.transactions.find({ id: paymentId })
+
+      return result as PaymentTransaction
+    } catch (error) {
+      throw new BusinessError('Houve uma falha buscar o boleto com paymentId: ' + paymentId, {
+        paymentId,
+        info: error,
+      })
+    }
+  }
+
+  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-api.adapter.ts

@@ -0,0 +1,226 @@
+import {
+  BusinessError,
+  BusinessUnitEnum,
+  CardInfo,
+  Checkout,
+  LineItem,
+  OrderBlockedRepository,
+  PagarMeCard,
+  PagarmeCredentials,
+  PagarmePaymentStatus,
+  Payment,
+  PaymentCardInfo,
+  PaymentError,
+  PaymentProviderCard,
+  PaymentProviders,
+  PaymentRepository,
+  PaymentTransaction,
+  Shops,
+} from '@infrab4a/connect'
+import pagarme from 'pagarme'
+
+export class PagarmeCardAPIAdapter implements PaymentProviderCard<PagarMeCard> {
+  constructor(
+    private credentials: PagarmeCredentials,
+    private paymentRepository: PaymentRepository,
+    private orderBlockedRepository: OrderBlockedRepository,
+  ) {}
+
+  public async pay(checkout: Checkout, card: PaymentCardInfo): Promise<Payment> {
+    try {
+      const client = await this.createPagarmeClient()
+      const transactionResult = await this.executeCardTransaction(client, checkout, card)
+
+      await this.validateTransactionResult(transactionResult, checkout, card)
+
+      return await this.createPaymentRecord(checkout, transactionResult)
+    } catch (error) {
+      this.handlePaymentError(error, checkout)
+    }
+  }
+
+  private async createPagarmeClient() {
+    return await pagarme.client.connect({ api_key: this.credentials.API_KEY })
+  }
+
+  private async executeCardTransaction(client: any, checkout: Checkout, card: PaymentCardInfo) {
+    const payload = this.createCardPayment(checkout, card)
+    const result = await client.transactions.create(payload)
+
+    this.logTransactionDetails(payload, result)
+
+    return result
+  }
+
+  private logTransactionDetails(payload: any, result: any): void {
+    console.warn('[PAGARME CARD DATA TO SEND]', payload)
+    console.warn('result PagarmeCardAPIAdapter', JSON.stringify(result))
+  }
+
+  private async validateTransactionResult(result: any, checkout: Checkout, card: PaymentCardInfo): Promise<void> {
+    if (result.status !== PagarmePaymentStatus.Pago) {
+      await this.handleUnauthorizedPayment(checkout, card, result)
+    }
+  }
+
+  private async handleUnauthorizedPayment(checkout: Checkout, card: PaymentCardInfo, result: any): Promise<never> {
+    await this.createBlockedOrderRecord(checkout, card)
+
+    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',
+      {
+        checkoutId: checkout.id,
+        userEmail: checkout.user.email,
+        info: result,
+      },
+    )
+  }
+
+  private async createBlockedOrderRecord(checkout: Checkout, card: PaymentCardInfo): Promise<void> {
+    await this.orderBlockedRepository.createBlockedOrderOrPayment({
+      checkout,
+      blockType: 'Card not authorized',
+      type: 'Card',
+      limiteRange: 'day',
+      card,
+    })
+  }
+
+  private async createPaymentRecord(checkout: Checkout, transactionResult: any): Promise<Payment> {
+    return await this.paymentRepository.create({
+      createdAt: new Date(),
+      updatedAt: new Date(),
+      userId: checkout.user.id,
+      checkoutId: checkout.id,
+      totalPrice: checkout.totalPrice,
+      paymentProvider: PaymentProviders.PAGARME,
+      transaction: { ...transactionResult, paidAt: new Date() },
+    })
+  }
+
+  private handlePaymentError(error: any, checkout: Checkout): never {
+    console.error('Error PagarmeCardAPIAdapter', JSON.stringify(error))
+
+    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',
+      {
+        checkoutId: checkout.id,
+        userEmail: checkout.user.email,
+        info: error,
+      },
+    )
+  }
+
+  public async addCard(card: CardInfo): Promise<PagarMeCard> {
+    try {
+      const client = await pagarme.client.connect({ api_key: this.credentials.API_KEY })
+      const result = await client.cards.create({
+        card_number: card.number,
+        card_expiration_date: card.expirationDate.replace('/', ''),
+        card_holder_name: card.name,
+        card_cvv: card.cvv,
+      })
+
+      return result as PagarMeCard
+    } catch (error) {
+      throw new BusinessError('Houve uma falha adicionar o cartão', {
+        info: error,
+      })
+    }
+  }
+
+  public async createCardHash(bu: BusinessUnitEnum, card: CardInfo): Promise<string> {
+    try {
+      const client = await pagarme.client.connect({ api_key: this.credentials.API_KEY })
+      const result = await client.security.encrypt({
+        card_number: card.number,
+        card_expiration_date: card.expirationDate.replace('/', ''),
+        card_holder_name: card.name,
+        card_cvv: card.cvv,
+      })
+
+      return result as string
+    } catch (error) {
+      throw new BusinessError('Houve uma falha ao gerar o hash do cartão', {
+        info: error,
+      })
+    }
+  }
+
+  public async getCardByToken(id: string): Promise<PagarMeCard> {
+    try {
+      const client = await pagarme.client.connect({ api_key: this.credentials.API_KEY })
+      const result = await client.cards.find({
+        id,
+      })
+
+      return result as PagarMeCard
+    } catch (error) {
+      throw new BusinessError('Houve uma falha buscar o cartão com id: ' + id, {
+        info: error,
+      })
+    }
+  }
+
+  public async createTransaction(data: any): Promise<PaymentTransaction> {
+    try {
+      const client = await pagarme.client.connect({ api_key: this.credentials.API_KEY })
+      const result = await client.transactions.create(data)
+
+      return result as PaymentTransaction
+    } catch (error) {
+      throw new BusinessError('Houve uma falha ao criar a transação', {
+        info: error,
+      })
+    }
+  }
+
+  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-api.adapter.ts

@@ -0,0 +1,69 @@
+import {
+  addDays,
+  Checkout,
+  format,
+  PagarmeCredentials,
+  Payment,
+  PaymentError,
+  PaymentProviderPix,
+  PaymentRepository,
+} from '@infrab4a/connect'
+import pagarme from 'pagarme'
+
+export class PagarmePixAPIAdapter implements PaymentProviderPix {
+  constructor(private credentials: PagarmeCredentials, private paymentRepository: PaymentRepository) {}
+
+  public async pay(checkout: Checkout): Promise<Payment> {
+    try {
+      const client = await pagarme.client.connect({ api_key: this.credentials.API_KEY })
+      const payload = this.createPixPayment(checkout)
+      const result = await client.transactions.create(payload)
+
+      console.warn('[PAGARME PIX DATA TO SEND]', payload)
+      console.warn('result PagarmePixAPIAdapter', JSON.stringify(result))
+
+      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,
+      })
+
+      return payment
+    } catch (error) {
+      console.error('Error PagarmePixAPIAdapter', JSON.stringify(error))
+      throw new PaymentError('Houve uma falha ao processar pagamento com pix', {
+        checkoutId: checkout.id,
+        userEmail: checkout.user.email,
+        info: error,
+      })
+    }
+  }
+
+  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/discovery-engine-adapter.ts

@@ -0,0 +1,148 @@
+import { DocumentServiceClient } from '@google-cloud/discoveryengine'
+import { SearchServiceClient } from '@google-cloud/discoveryengine/build/src/v1beta'
+import { ProductBulk, ProductHasuraGraphQL, ProductSearch, VertexSearchAdapter } from '@infrab4a/connect'
+import { Inject, Injectable } from '@nestjs/common'
+
+import { VERTEX_CONFIG } from '../../../consts'
+import { ProductVertexHelper } from '../helpers/product-vertex-ai.helper'
+import { VertexConfig, VertexSearchResult } from '../types'
+
+@Injectable()
+export class DiscoveryEngineVertexAdapter implements VertexSearchAdapter<ProductSearch> {
+  private config: VertexConfig
+  private parentEngine: string
+  private parentDataStore: string
+  private servingConfig: string
+  private searchClient
+  private documentClient
+
+  constructor(@Inject(VERTEX_CONFIG) configuration: VertexConfig) {
+    this.config = configuration
+    this.parentEngine =
+      `projects/${this.config.projectId}/locations/${this.config.location}/` +
+      `collections/default_collection/engines/${this.config.dataStoreId}`
+    this.parentDataStore =
+      `projects/${this.config.projectId}/locations/${this.config.location}/` +
+      `collections/default_collection/dataStores/${this.config.dataStoreId}/branches/default_branch/documents`
+    this.searchClient = new SearchServiceClient({
+      apiEndpoint: configuration.apiEndpoint,
+      credentials: configuration.credentials,
+    })
+    this.documentClient = new DocumentServiceClient({
+      apiEndpoint: configuration.apiEndpoint,
+      credentials: configuration.credentials,
+    })
+    this.servingConfig = this.searchClient.projectLocationCollectionDataStoreServingConfigPath(
+      configuration.projectId,
+      configuration.location,
+      configuration.collectionId,
+      configuration.dataStoreId,
+      configuration.servingConfigId,
+    )
+  }
+
+  public async save(product: ProductHasuraGraphQL) {
+    const productSearch = ProductVertexHelper.productMapper(product)
+
+    const request = {
+      parent: this.parentEngine,
+      allowMissing: true,
+      document: {
+        name: this.parentDataStore + `/${product.id}`,
+        jsonData: JSON.stringify(productSearch),
+        data: 'jsonData',
+      },
+    }
+
+    const response = await this.documentClient.updateDocument(request)
+
+    return response
+  }
+
+  public async update(id: string, data: ProductHasuraGraphQL) {
+    const productSearch = ProductVertexHelper.productMapper(data)
+
+    const request = {
+      parent: this.parentEngine,
+      allowMissing: true,
+      document: {
+        name: this.parentDataStore + `/${id}`,
+        jsonData: JSON.stringify(productSearch),
+        data: 'jsonData',
+      },
+    }
+
+    const response = await this.documentClient.updateDocument(request)
+
+    return response
+  }
+
+  public async query(term: string, total: number) {
+    const response = (await this.searchClient.search(
+      {
+        pageSize: total,
+        query: term,
+        filter: '',
+        languageCode: 'pt-BR',
+        servingConfig: this.servingConfig,
+        relevanceThreshold: 'MEDIUM',
+      },
+      {
+        autoPaginate: false,
+      },
+    )) as VertexSearchResult<ProductSearch>
+
+    return ProductVertexHelper.resultProductMapper(response)
+  }
+
+  public async get(id: string) {
+    const request = {
+      name: this.parentDataStore + `/${id}`,
+    }
+
+    const response = await this.documentClient.getDocument(request)
+    const document = JSON.parse(response[0].jsonData)
+
+    return document
+  }
+
+  public async delete(id: string) {
+    const request = {
+      name: this.parentDataStore + `/${id}`,
+    }
+
+    await this.documentClient.deleteDocument(request)
+  }
+
+  public async bulkProducts(products: ProductBulk[]): Promise<void> {
+    try {
+      const batchSize = 100
+      let total = 0
+
+      for (let index = 0; index < products.length; index += batchSize) {
+        const bulkProducts = products.slice(index, index + batchSize)
+
+        const [operation] = await this.documentClient.importDocuments({
+          parent:
+            `projects/${this.config.projectId}/locations/${this.config.location}/` +
+            `collections/default_collection/dataStores/${this.config.dataStoreId}/branches/default_branch`,
+          inlineSource: {
+            documents: bulkProducts,
+          },
+        })
+
+        total += bulkProducts.length
+        const [response] = await operation.promise()
+
+        console.warn(
+          `Imported: ${total} documents`,
+          ((total / products.length) * 100).toFixed(2) + '%',
+          'Erros: ',
+          response.errorSamples ? response.errorSamples : [],
+        )
+      }
+    } catch (error) {
+      console.error(error)
+    }
+  }
+}

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

@@ -0,0 +1 @@
+export * from './discovery-engine-adapter'

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

@@ -0,0 +1 @@
+export * from './product-vertex-ai.helper'

package/src/infra/vertex-ai/helpers/product-vertex-ai.helper.ts

@@ -0,0 +1,52 @@
+import { ProductHasuraGraphQL, ProductSearch } from '@infrab4a/connect'
+
+import { VertexSearchResult } from '../types'
+
+export class ProductVertexHelper {
+  constructor() {}
+
+  public static productMapper(product: ProductHasuraGraphQL): ProductSearch {
+    const image = product.miniatures && (product.miniatures as string[]).length ? product.miniatures[0] : null
+
+    return {
+      id: product.id.toString(),
+      miniatures: image,
+      icon: image,
+      name: product.name,
+      brand: product.brand?.toString().trim() ? product.brand?.toString().trim() : null,
+      ean: product.EAN,
+      sku: product.sku,
+      slug: product.slug,
+      published: product.published,
+      gender: product.gender,
+      stock: product.stock.quantity,
+      rating: product.rate,
+      shoppingCount: product.shoppingCount,
+      description: product.description.description,
+      fullPrice: product.fullPrice,
+      price: product.price.price,
+      subscriberPrice: product.subscriberPrice,
+      outlet: product.outlet,
+      createdAt: product.createdAt,
+    }
+  }
+
+  public static resultProductMapper(result: VertexSearchResult<ProductSearch>): ProductSearch[] {
+    return result[0].length
+      ? result[0].map((result) => {
+          return {
+            id: result.document?.structData.fields.id.stringValue,
+            name: result.document?.structData.fields.name.stringValue,
+            brand: result.document?.structData.fields.brand?.stringValue,
+            stock: result.document?.structData.fields.stock?.numberValue,
+            rating: result.document?.structData.fields.rating?.stringValue,
+            gender: result.document?.structData.fields.gender?.stringValue,
+            slug: result.document?.structData.fields.slug?.stringValue,
+            sku: result.document?.structData.fields.sku?.stringValue,
+            ean: result.document?.structData.fields.ean?.stringValue,
+            description: result.document?.structData.fields.description?.stringValue,
+          } as any
+        })
+      : []
+  }
+}

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

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

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

@@ -0,0 +1,2 @@
+export * from './vertex-config'
+export * from './vertex-search-result'

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

@@ -0,0 +1,23 @@
+export type VertexConfig = {
+  credentials: {
+    type: string
+    project_id: string
+    private_key_id: string
+    private_key: string
+    client_email: string
+    client_id: string
+    auth_uri?: string
+    token_uri?: string
+    auth_provider_x509_cert_url?: string
+    client_x509_cert_url?: string
+    apiKey?: string
+    authDomain?: string
+  }
+  apiEndpoint: string
+  projectId: string
+  location: string
+  dataStoreId: string
+  collectionId: string
+  engine: string
+  servingConfigId: string
+}

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

@@ -0,0 +1,17 @@
+import { protos } from '@google-cloud/discoveryengine'
+
+export type VertexSearchResult<T> = [
+  VertexResult<T>[],
+  protos.google.cloud.discoveryengine.v1.ISearchRequest | null,
+  protos.google.cloud.discoveryengine.v1.ISearchResponse,
+]
+
+type VertexResult<T> = {
+  id?: string | null
+  document?: {
+    structData: {
+      fields: { [P in keyof T]: any }
+    }
+  }
+  chunk?: protos.google.cloud.discoveryengine.v1.IChunk
+}

package/src/nest-connect.module.ts

@@ -0,0 +1,36 @@
+import { isNil } from '@infrab4a/connect'
+import { DynamicModule, Module } from '@nestjs/common'
+
+import { ESClientOptions, VertexConfig } from './infra'
+import { NestElasticSeachModule } from './nest-elastic-search.module'
+import { NestFirestoreModule } from './nest-firestore.module'
+import { HasuraGraphQLOptions, NestHasuraGraphQLModule } from './nest-hasura-graphql.module'
+import { NestVertexSeachModule } from './nest-vertex-ai-search.module'
+
+@Module({})
+export class NestConnectModule {
+  public static initializeApp(options: {
+    firebase?: {
+      googleApplicationCredential: string
+    }
+    elasticSearch?: ESClientOptions
+    hasura: HasuraGraphQLOptions
+    vertex?: VertexConfig
+  }): DynamicModule {
+    return {
+      module: NestConnectModule,
+      imports: [
+        ...(options.firebase ? [NestFirestoreModule.initializeApp({ firebase: options.firebase })] : []),
+        ...(isNil(options?.hasura) ? [] : [NestHasuraGraphQLModule.initializeApp(options.hasura)]),
+        ...(isNil(options?.elasticSearch) ? [] : [NestElasticSeachModule.initializeApp(options.elasticSearch)]),
+        ...(isNil(options?.vertex) ? [] : [NestVertexSeachModule.initializeApp(options.vertex)]),
+      ],
+      exports: [
+        ...(options.firebase ? [NestFirestoreModule] : []),
+        ...(isNil(options?.hasura) ? [] : [NestHasuraGraphQLModule]),
+        ...(isNil(options?.elasticSearch) ? [] : [NestElasticSeachModule]),
+        ...(isNil(options?.vertex) ? [] : [NestVertexSeachModule]),
+      ],
+    }
+  }
+}