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

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

@@ -0,0 +1,76 @@
+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

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

package/src/infra/adyen/index.ts

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

package/src/infra/cache/index.ts

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

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

@@ -0,0 +1,91 @@
+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

@@ -0,0 +1,138 @@
+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

@@ -0,0 +1,9 @@
+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

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

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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,62 @@
+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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,4 @@
+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

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

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

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

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

@@ -0,0 +1,53 @@
+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

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

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

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

package/src/infra/firebase/auth/authentication-firebase-auth.service.ts

@@ -0,0 +1,60 @@
+import {
+  Auth,
+  browserPopupRedirectResolver,
+  GoogleAuthProvider,
+  sendPasswordResetEmail,
+  signInAnonymously,
+  signInWithEmailAndPassword,
+  signInWithPopup,
+} from 'firebase/auth'
+
+import { AuthenticationService, BasicUserData, LoginAndPasswordParams } from '../../../domain'
+
+import { FirebaseUserWithId } from './types/firebase-user-with-id.type'
+
+export class AuthenticationFirebaseAuthService implements AuthenticationService {
+  constructor(private readonly firebaseAuth: Auth) {}
+
+  async signInWithEmailAndPassword(data: LoginAndPasswordParams): Promise<BasicUserData> {
+    const credentials = await signInWithEmailAndPassword(this.firebaseAuth, data.email, data.password)
+    const user = credentials.user
+
+    return {
+      id: user.uid,
+      displayName: user.displayName,
+      email: user.email,
+      phone: user.phoneNumber,
+      isAnonymous: false,
+    }
+  }
+
+  async signInWithGoogle(): Promise<BasicUserData> {
+    const credentials = await signInWithPopup(this.firebaseAuth, new GoogleAuthProvider(), browserPopupRedirectResolver)
+    const user = credentials.user
+
+    return {
+      id: user.uid,
+      displayName: user.displayName,
+      email: user.email,
+      phone: user.phoneNumber,
+      isAnonymous: false,
+    }
+  }
+
+  async signOut(): Promise<void> {
+    this.firebaseAuth.signOut()
+  }
+
+  async signInAnonymously(): Promise<FirebaseUserWithId> {
+    const auth = await signInAnonymously(this.firebaseAuth)
+    const user = auth.user as FirebaseUserWithId
+
+    user.id = auth.user.uid
+
+    return user
+  }
+
+  async sendPasswordResetEmail(email: string): Promise<void> {
+    return sendPasswordResetEmail(this.firebaseAuth, email)
+  }
+}

package/src/infra/firebase/auth/index.ts

@@ -0,0 +1,2 @@
+export * from './authentication-firebase-auth.service'
+export * from './register-firebase-auth.service'

package/src/infra/firebase/auth/register-firebase-auth.service.ts

@@ -0,0 +1,39 @@
+import { FirebaseError } from 'firebase/app'
+import { Auth, createUserWithEmailAndPassword, sendEmailVerification } from 'firebase/auth'
+
+import { RegisterParams, RegisterService, UserAlreadyRegisteredError, WeakPasswordError } from '../../../domain'
+import { RequiredArgumentError } from '../../../errors'
+import { is } from '../../../utils'
+
+import { FirebaseUserWithId } from './types/firebase-user-with-id.type'
+
+export class RegisterFirebaseAuthService implements RegisterService {
+  constructor(private readonly firebaseAuth: Auth) {}
+
+  async register(params: RegisterParams): Promise<FirebaseUserWithId> {
+    if (!params.email) throw new RequiredArgumentError(['email'])
+
+    try {
+      const auth = await createUserWithEmailAndPassword(this.firebaseAuth, params.email, params.password)
+      const user = is<FirebaseUserWithId>(auth.user)
+
+      if (!user) throw new Error('User not created')
+
+      await sendEmailVerification(user)
+      user.id = user.uid
+
+      return user
+    } catch (error) {
+      if (!(error instanceof Error)) throw error
+
+      const firebaseError = error as FirebaseError
+
+      if (firebaseError.code === 'auth/email-already-in-use')
+        throw new UserAlreadyRegisteredError('Email already registered')
+
+      if (firebaseError.code === 'auth/weak-password') throw new WeakPasswordError()
+
+      throw error
+    }
+  }
+}