@infrab4a/connect 6.0.0-alpha.0 → 6.0.0-alpha.1

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'

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

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

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

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

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

package/src/infra/firebase/auth/types/firebase-user-with-id.type.ts

@@ -1,5 +0,0 @@
-import { User } from 'firebase/auth'
-
-import { BasicUserData } from '../../../../domain'
-
-export type FirebaseUserWithId = BasicUserData & User & { id: string }

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

@@ -1 +0,0 @@
-export * from './firebase-user-with-id.type'

package/src/infra/firebase/firestore/enums/firestore-field-type.enum.ts

@@ -1,8 +0,0 @@
-export enum FirestoreFieldType {
-  String = 'string',
-  Number = 'number',
-  Boolean = 'boolean',
-  Timestamp = 'timestamp',
-  Array = 'array',
-  Map = 'map',
-}

package/src/infra/firebase/firestore/enums/index.ts

@@ -1 +0,0 @@
-export * from './firestore-field-type.enum'

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

@@ -1,5 +0,0 @@
-export * from './mixins'
-export * from './repositories'
-export * from './services'
-export * from './types'
-export * from './vo'

package/src/infra/firebase/firestore/mixins/helpers/cache-key-generator.helper.ts

@@ -1,27 +0,0 @@
-import { ModelBaseStructure } from '../../../../../domain'
-import { MD5GeneratorHelper } from '../../../../hasura-graphql/mixins/helpers'
-
-export class FirestoreCacheKeyGeneratorHelper {
-  static generateGetCacheKey<Model extends ModelBaseStructure<Model>>(
-    model: { name: string },
-    identifiers: Record<string, any>,
-  ): string {
-    const sortedEntries = Object.entries(identifiers).sort(([keyA], [keyB]) => keyA.localeCompare(keyB))
-    const keyParts: string[] = []
-
-    for (const [key, value] of sortedEntries) {
-      keyParts.push(`${key}:${value}`)
-    }
-
-    return `${model.name.toLowerCase()}:get:${keyParts.join(':')}`
-  }
-
-  static generateFindCacheKey<Model extends ModelBaseStructure<Model>>(
-    model: { name: string },
-    findParams: any,
-  ): string {
-    const md5 = MD5GeneratorHelper.generateMD5(findParams)
-
-    return `${model.name.toLowerCase()}:find:${md5}`
-  }
-}