@infrab4a/connect 5.7.3 → 5.7.4

package/src/infra/adyen/helpers/adyen-blocked-order.helper.ts

@@ -1,43 +0,0 @@
-import { Checkout } from '../../../domain/shopping/models'
-import { OrderBlockedRepository } from '../../../domain/shopping/repositories'
-import { PaymentCardInfo } from '../../../domain/shopping/types'
-import { ErrorsCode, PaymentError } from '../../../errors'
-
-export class AdyenBlockedOrderHelper {
-  static async handleUnauthorizedPayment(params: {
-    checkout: Checkout
-    card: PaymentCardInfo
-    orderBlockedRepository: OrderBlockedRepository
-    adyenResponse: any
-  }): Promise<never> {
-    await params.orderBlockedRepository.createBlockedOrderOrPayment({
-      checkout: params.checkout,
-      blockType: 'Card not authorized',
-      type: 'Card',
-      limiteRange: 'day',
-      card: params.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',
-      ErrorsCode.paymentError,
-      {
-        checkoutId: params.checkout.id,
-        userEmail: params.checkout.user.email,
-        info: params.adyenResponse,
-      },
-    )
-  }
-
-  static createPaymentError(checkout: Checkout, errorInfo: any): PaymentError {
-    return 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: errorInfo,
-      },
-    )
-  }
-}

package/src/infra/adyen/helpers/adyen-payment-factory.helper.ts

@@ -1,24 +0,0 @@
-import { Checkout, Payment } from '../../../domain/shopping/models'
-import { PaymentRepository } from '../../../domain/shopping/repositories'
-
-import { AdyenPaymentResponse } from './adyen-payment-operations.helper'
-
-export class AdyenPaymentFactoryHelper {
-  static async createPaymentFromAdyenResponse(
-    checkout: Checkout,
-    adyenResponse: AdyenPaymentResponse,
-    paymentRepository: PaymentRepository,
-  ): Promise<Payment> {
-    const paymentData = Payment.toInstance({
-      createdAt: new Date(),
-      updatedAt: new Date(),
-      userId: checkout.user.id,
-      checkoutId: checkout.id,
-      totalPrice: checkout.totalPrice,
-      paymentProvider: 'adyen',
-      transaction: { ...adyenResponse, status: 'paid' } as any,
-    })
-
-    return paymentRepository.create(paymentData)
-  }
-}

package/src/infra/adyen/helpers/adyen-payment-operations.helper.ts

@@ -1,76 +0,0 @@
-import axios, { AxiosResponse } from 'axios'
-
-import { Checkout } from '../../../domain/shopping/models'
-import { AdyenCredentials, PaymentCardInfo } from '../../../domain/shopping/types'
-
-export interface AdyenPaymentRequest {
-  amount: {
-    currency: string
-    value: number
-  }
-  paymentMethod: {
-    type: string
-    storedPaymentMethodId: string
-  }
-  reference: string
-  shopperInteraction: string
-  merchantAccount: string
-  shopperReference: string
-  recurringProcessingModel: string
-  returnUrl: string
-  installments: {
-    value: number
-  }
-}
-
-export interface AdyenPaymentResponse {
-  resultCode: 'Authorised' | 'Refused' | 'Error' | string
-  [key: string]: any
-}
-
-export class AdyenPaymentOperationsHelper {
-  static buildPaymentRequest(
-    checkout: Checkout,
-    card: PaymentCardInfo,
-    credentials: AdyenCredentials,
-  ): AdyenPaymentRequest {
-    return {
-      amount: {
-        currency: 'BRL',
-        value: (checkout?.totalPrice || 0) * 100,
-      },
-      paymentMethod: {
-        type: 'scheme',
-        storedPaymentMethodId: card.cardId,
-      },
-      reference: checkout.id,
-      shopperInteraction: 'Ecommerce',
-      merchantAccount: credentials.MERCHANT_ACCOUNT,
-      shopperReference: checkout.user.id,
-      recurringProcessingModel: 'CardOnFile',
-      returnUrl: credentials.URL_POSTBACK,
-      installments: {
-        value: card.installments,
-      },
-    }
-  }
-
-  static async executePaymentRequest(
-    paymentRequest: AdyenPaymentRequest,
-    credentials: AdyenCredentials,
-  ): Promise<AxiosResponse<AdyenPaymentResponse>> {
-    return axios({
-      method: 'POST',
-      url: credentials.URL_TRANSACTION,
-      headers: {
-        'x-api-key': credentials.API_KEY,
-        'content-type': 'application/json',
-      },
-      data: paymentRequest,
-    })
-  }
-
-  static isPaymentAuthorised(response: AdyenPaymentResponse): boolean {
-    return response.resultCode === 'Authorised'
-  }
-}

package/src/infra/adyen/helpers/index.ts

@@ -1,3 +0,0 @@
-export * from './adyen-blocked-order.helper'
-export * from './adyen-payment-factory.helper'
-export * from './adyen-payment-operations.helper'

package/src/infra/adyen/index.ts

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

package/src/infra/cache/index.ts

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

package/src/infra/cache/restcache.adapter.ts

@@ -1,91 +0,0 @@
-import axios, { AxiosInstance } from 'axios'
-
-import { CacheAdapter, CacheOptions } from '../../domain/general/cacheadapter'
-import { DebugHelper, isNil } from '../../utils'
-
-export interface RESTCacheConfig {
-  baseURL: string
-  authToken?: string
-  mobileApiKey?: string
-}
-
-export class RestCacheAdapter implements CacheAdapter {
-  private client: AxiosInstance
-  private readonly logger: DebugHelper
-
-  constructor(config: RESTCacheConfig) {
-    this.logger = new DebugHelper('RestCacheAdapter')
-    this.client = axios.create({
-      baseURL: config.baseURL,
-      headers: {
-        'Content-Type': 'application/json',
-        ...(isNil(config.authToken) ? {} : { Authorization: `Bearer ${config.authToken}` }),
-        ...(isNil(config.mobileApiKey) ? {} : { 'X-Mobile-API-Key': config.mobileApiKey }),
-      },
-    })
-  }
-
-  async set(options: CacheOptions): Promise<boolean> {
-    try {
-      const response = await this.client.post('/redis/set', {
-        key: options.key,
-        data: options.data,
-        ex: options.expirationInSeconds,
-      })
-
-      return response.data.success
-    } catch (error) {
-      if (error instanceof Error)
-        this.logger.error(new Error(`[RestCacheAdapter] Erro ao definir cache: ${error.message}`))
-
-      return false
-    }
-  }
-
-  async get<T = any>(key: string): Promise<T | null> {
-    try {
-      const response = await this.client.post('/redis/get', {
-        key,
-      })
-
-      if (response.data.success) {
-        return response.data.data as T
-      }
-
-      return null
-    } catch (error) {
-      if (error instanceof Error)
-        this.logger.error(new Error(`[RestCacheAdapter] Erro ao recuperar cache: ${error.message}`))
-
-      return null
-    }
-  }
-
-  async remove(key: string): Promise<boolean> {
-    try {
-      const response = await this.client.post('/redis/del', {
-        key,
-      })
-
-      return response.data.success
-    } catch (error) {
-      if (error instanceof Error)
-        this.logger.error(new Error(`[RestCacheAdapter] Erro ao remover cache: ${error.message}`))
-
-      return false
-    }
-  }
-
-  async clear(): Promise<boolean> {
-    try {
-      const response = await this.client.post('/redis/flushdb', {})
-
-      return response.data.success
-    } catch (error) {
-      if (error instanceof Error)
-        this.logger.error(new Error(`[RestCacheAdapter] Erro ao limpar cache: ${error.message}`))
-
-      return false
-    }
-  }
-}

package/src/infra/elasticsearch/adapters/axios.adapter.ts

@@ -1,138 +0,0 @@
-import axios, { AxiosRequestConfig } from 'axios'
-
-import { ModelBaseStructure } from '../../../domain'
-import { NotFoundError } from '../../../errors'
-import { DebugHelper } from '../../../utils'
-import { ElasticSearchResult } from '../types/elastic-search-result'
-
-import { ElasticSearchAdapter } from './elastic-search.adapter'
-
-export type AxiosElasticSearchConfig = {
-  url: string
-  credential: string
-}
-
-export class AxiosAdapter<T extends ModelBaseStructure<T>> implements ElasticSearchAdapter<T> {
-  private logger: DebugHelper
-
-  constructor(private readonly config: AxiosElasticSearchConfig) {
-    this.logger = DebugHelper.from(this)
-  }
-
-  async get(index: string, id: string): Promise<T> {
-    const logger = this.logger.with('get')
-    const req: AxiosRequestConfig = {
-      url: `${this.config.url}/${index}/_doc/${id}`,
-      method: 'GET',
-      responseType: 'json',
-      headers: {
-        'Content-Type': 'application/json',
-        Authorization: `ApiKey ${this.config.credential}`,
-      },
-    }
-
-    try {
-      const { data } = await axios(req)
-
-      logger.log({ req, res: data })
-
-      return data._source
-    } catch (error) {
-      logger.error({ req, res: error })
-
-      if (!(error instanceof Error)) throw error
-
-      throw new NotFoundError(error.message)
-    }
-  }
-
-  async query(index: string, query: any): Promise<ElasticSearchResult<T>> {
-    const logger = this.logger.with('query')
-    const req: AxiosRequestConfig = {
-      url: `${this.config.url}/${index}/_search`,
-      method: 'POST',
-      responseType: 'json',
-      headers: {
-        Accept: 'application/vnd.elasticsearch+json;compatible-with=7',
-        'Content-Type': 'application/vnd.elasticsearch+json;compatible-with=7',
-        Authorization: `ApiKey ${this.config.credential}`,
-      },
-      data: query,
-    }
-
-    try {
-      const { data } = await axios(req)
-      const res = {
-        total: data.hits.total.value,
-        hits: data.hits.hits,
-      }
-
-      logger.log({ req, res })
-
-      return res
-    } catch (error) {
-      logger.error({ req, res: error })
-
-      throw error
-    }
-  }
-
-  async save(index: string, data: T): Promise<void> {
-    const logger = this.logger.with('save')
-    const req = {
-      url: `${this.config.url}/${index}/_doc`,
-      method: 'POST',
-      headers: { Authorization: `ApiKey ${this.config.credential}` },
-      data,
-    }
-
-    try {
-      await axios(req)
-
-      logger.log({ req, res: undefined })
-    } catch (error) {
-      logger.error({ req, res: error })
-
-      throw error
-    }
-  }
-
-  async update(index: string, id: string, data: Partial<T>): Promise<void> {
-    const logger = this.logger.with('update')
-    const req = {
-      url: `${this.config.url}/${index}/_update/${id}`,
-      method: 'PUT',
-      headers: { Authorization: `ApiKey ${this.config.credential}` },
-      data,
-    }
-
-    try {
-      await axios(req)
-
-      logger.log({ req, res: undefined })
-    } catch (error) {
-      logger.error({ req, res: error })
-
-      throw error
-    }
-  }
-
-  async delete(index: string, id: string): Promise<void> {
-    const logger = this.logger.with('delete')
-    const req = {
-      url: `${this.config.url}/${index}/_doc/${id}`,
-      method: 'DELETE',
-      headers: { Authorization: `ApiKey ${this.config.credential}` },
-    }
-
-    try {
-      await axios(req)
-
-      logger.log({ req, res: undefined })
-    } catch (error) {
-      logger.error({ req, res: error })
-
-      throw error
-    }
-  }
-}

package/src/infra/elasticsearch/adapters/elastic-search.adapter.ts

@@ -1,9 +0,0 @@
-import { ElasticSearchResult } from '../types/elastic-search-result'
-
-export interface ElasticSearchAdapter<T = any> {
-  get(index: string, id: string): Promise<T>
-  query(index: string, query: any): Promise<ElasticSearchResult<T>>
-  save(index: string, data: T): Promise<void>
-  update(index: string, id: string, data: Partial<T>): Promise<void>
-  delete(index: string, id: string): Promise<void>
-}

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

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

package/src/infra/elasticsearch/helpers/elasticsearch-fields.helper.ts

@@ -1,27 +0,0 @@
-export class ElasticSearchFieldsHelper {
-  static getProductSearchFields(total: number): string[] {
-    const baseFields = [
-      'EAN',
-      'brand',
-      'id',
-      'images',
-      'miniatures',
-      'name',
-      'price',
-      'sku',
-      'stock',
-      'slug',
-      'reviews',
-      'hasVariants',
-      'rate',
-    ]
-
-    const extendedFields = ['pricePaid', 'isGift', 'stock', 'weight', 'tags']
-
-    return total > 9 ? [...baseFields, ...extendedFields] : baseFields
-  }
-
-  static getProductSearchFilters(): Array<{ term: { [key: string]: string | boolean | number } }> {
-    return [{ term: { published: true } }]
-  }
-}

package/src/infra/elasticsearch/helpers/elasticsearch-query-builder.helper.ts

@@ -1,62 +0,0 @@
-export interface ElasticSearchQuery {
-  should: any[]
-  filter: Array<{ term: { [key: string]: string | boolean | number } }>
-}
-
-export class ElasticSearchQueryBuilderHelper {
-  static buildProductSearchQuery(
-    searchTerm: string,
-    filters: Array<{ term: { [key: string]: string | boolean | number } }>,
-  ): ElasticSearchQuery {
-    const query: ElasticSearchQuery = {
-      should: [
-        {
-          match_phrase: {
-            name: {
-              query: searchTerm,
-              boost: 4,
-            },
-          },
-        },
-        {
-          match_phrase: {
-            brand: {
-              query: searchTerm,
-              boost: 2,
-            },
-          },
-        },
-      ],
-      filter: filters,
-    }
-
-    return this.addComplementarySearchRules(query, searchTerm)
-  }
-
-  private static addComplementarySearchRules(query: ElasticSearchQuery, searchTerm: string): ElasticSearchQuery {
-    const complementSearch = searchTerm.split(' ')
-
-    if (complementSearch.length > 1) {
-      query.should.push(
-        {
-          multi_match: {
-            query: searchTerm,
-            fields: ['name'],
-            operator: 'AND',
-            boost: 3,
-          },
-        },
-        {
-          match_phrase: {
-            name: {
-              query: complementSearch.shift(),
-              boost: 1,
-            },
-          },
-        },
-      )
-    }
-
-    return query
-  }
-}

package/src/infra/elasticsearch/helpers/elasticsearch-result-processor.helper.ts

@@ -1,30 +0,0 @@
-import { Product, RoundProductPricesHelper } from '../../../domain'
-import { ElasticSearchResult } from '../types'
-
-export class ElasticSearchResultProcessorHelper {
-  static processProductSearchResults(search: ElasticSearchResult<Product>): any[] {
-    const filteredHits = this.filterValidHits(search.hits)
-    const processedHits = this.applyPriceRounding(filteredHits)
-
-    return this.transformHitsToProducts(processedHits)
-  }
-
-  private static filterValidHits(hits: any[]): any[] {
-    return hits.filter((hit: any) => hit._source.name !== '')
-  }
-
-  private static applyPriceRounding(hits: any[]): any[] {
-    return hits.map((hit) => {
-      RoundProductPricesHelper.roundProductPrices(hit._source)
-
-      return hit
-    })
-  }
-
-  private static transformHitsToProducts(hits: any[]): any[] {
-    return hits.map((hit) => ({
-      ...hit._source,
-      stock: hit._source.stock.quantity,
-    }))
-  }
-}

package/src/infra/elasticsearch/helpers/elasticsearch-search-operations.helper.ts

@@ -1,45 +0,0 @@
-import { Product } from '../../../domain'
-import { ElasticSearchAdapter } from '../adapters'
-import { ElasticSearchResult } from '../types'
-
-import { ElasticSearchFieldsHelper } from './elasticsearch-fields.helper'
-import { ElasticSearchQueryBuilderHelper } from './elasticsearch-query-builder.helper'
-import { ElasticSearchResultProcessorHelper } from './elasticsearch-result-processor.helper'
-
-export interface ProductSearchParams {
-  searchTerm: string
-  total: number
-  shop?: string
-}
-
-export class ElasticSearchOperationsHelper {
-  static async executeProductSearch(
-    params: ProductSearchParams,
-    adapter: ElasticSearchAdapter<Product>,
-    index: string,
-  ): Promise<any[]> {
-    const { searchTerm, total } = params
-    const size = total || 9
-
-    const fields = ElasticSearchFieldsHelper.getProductSearchFields(total)
-    const filters = ElasticSearchFieldsHelper.getProductSearchFilters()
-    const query = ElasticSearchQueryBuilderHelper.buildProductSearchQuery(searchTerm, filters)
-
-    const searchResult = await this.performSearch(adapter, index, {
-      size,
-      min_score: 1,
-      _source: fields,
-      query: { bool: query },
-    })
-
-    return ElasticSearchResultProcessorHelper.processProductSearchResults(searchResult)
-  }
-
-  private static async performSearch(
-    adapter: ElasticSearchAdapter<Product>,
-    index: string,
-    searchQuery: any,
-  ): Promise<ElasticSearchResult<Product>> {
-    return adapter.query(index, searchQuery)
-  }
-}

package/src/infra/elasticsearch/helpers/index.ts

@@ -1,4 +0,0 @@
-export * from './elasticsearch-fields.helper'
-export * from './elasticsearch-query-builder.helper'
-export * from './elasticsearch-result-processor.helper'
-export * from './elasticsearch-search-operations.helper'

package/src/infra/elasticsearch/index.ts

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

package/src/infra/elasticsearch/indexes/index.ts

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

package/src/infra/elasticsearch/indexes/products-index.ts

@@ -1,53 +0,0 @@
-import { Product } from '../../../domain'
-import { omit } from '../../../utils'
-import { ProductHasuraGraphQL } from '../../hasura-graphql'
-import { ElasticSearchAdapter } from '../adapters'
-import { ElasticSearchOperationsHelper, ProductSearchParams } from '../helpers'
-
-export class ProductsIndex {
-  private index = `products`
-  constructor(private readonly adapter: ElasticSearchAdapter<Product>) {}
-
-  async getById(id: string): Promise<Product> {
-    const data = await this.adapter.get(this.index, id)
-
-    return Product.toInstance(data)
-  }
-
-  async search(searchTerm: string, total: number, shop?: string) {
-    const searchParams: ProductSearchParams = {
-      searchTerm,
-      total,
-      shop,
-    }
-
-    return ElasticSearchOperationsHelper.executeProductSearch(searchParams, this.adapter, this.index)
-  }
-
-  async save(product: ProductHasuraGraphQL): Promise<void> {
-    try {
-      const data = omit(product.toPlain(), ['createdAt', 'updatedAt', 'kitProducts'])
-      const newProduct = Product.toInstance(data)
-
-      this.adapter.save(this.index, newProduct)
-    } catch (error) {
-      console.error(error)
-    }
-  }
-
-  async update(product: ProductHasuraGraphQL) {
-    try {
-      await this.adapter.update(this.index, product.id, product)
-    } catch (error) {
-      console.error(error)
-    }
-  }
-
-  async delete(id: string): Promise<void> {
-    try {
-      await this.adapter.delete(this.index, id)
-    } catch (error) {
-      console.error(error)
-    }
-  }
-}

package/src/infra/elasticsearch/types/elastic-search-result.ts

@@ -1,9 +0,0 @@
-export type ElasticSearchResult<T> = {
-  total: number
-  hits: {
-    _index: string
-    _id: string
-    _score: number
-    _source: T
-  }[]
-}

package/src/infra/elasticsearch/types/index.ts

@@ -1 +0,0 @@
-export * from './elastic-search-result'