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

package/src/infra/hasura-graphql/repositories/catalog/filter-option-hasura-graphql.repository.ts

@@ -1,32 +0,0 @@
-import { FilterOption } from '../../../../domain'
-import { FilterOptionRepository } from '../../../../domain/catalog/repositories'
-import { Base } from '../../../../utils'
-import { HasuraConstructorParams, withCrudHasuraGraphQL, withHasuraGraphQL } from '../../mixins'
-
-export class FilterOptionHasuraGraphQLRepository
-  extends withCrudHasuraGraphQL(withHasuraGraphQL<FilterOption>(Base))
-  implements FilterOptionRepository
-{
-  constructor({
-    endpoint,
-    authOptions,
-    interceptors,
-    cache,
-  }: Pick<HasuraConstructorParams<FilterOption>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>) {
-    super({
-      tableName: 'filter_option',
-      model: FilterOption,
-      endpoint,
-      authOptions,
-      interceptors,
-      fields: [
-        'id',
-        'description',
-        { filterId: { columnName: 'filter_id' } },
-        { createdAt: { columnName: 'created_at' } },
-        { updatedAt: { columnName: 'updated_at' } },
-      ],
-      cache,
-    })
-  }
-}

package/src/infra/hasura-graphql/repositories/catalog/helpers/category-cache-operations.helper.ts

@@ -1,55 +0,0 @@
-import { CacheAdapter, Category, Product, RepositoryCacheOptions, Shops } from '../../../../../domain'
-import { DebugHelper, deserialize, serialize } from '../../../../../utils'
-import { MD5GeneratorHelper } from '../../../mixins/helpers'
-import { ProductHasuraGraphQL } from '../../../models'
-
-export interface CategoryCacheParams {
-  category: Category
-  shop: Shops
-  options: { limit?: number; hasStock?: boolean }
-  optionsCache: { cache?: RepositoryCacheOptions }
-}
-
-export class CategoryCacheOperationsHelper {
-  static generateCacheKey(category: Category, shop: Shops, options: { limit?: number; hasStock?: boolean }): string {
-    return `categoryhashragraphql:mountCategory:${category.id}:${shop}:${MD5GeneratorHelper.generateMD5(options)}`
-  }
-
-  static async getCachedProducts(
-    cacheAdapter: CacheAdapter,
-    cacheKey: string,
-    logger: DebugHelper,
-  ): Promise<ProductHasuraGraphQL[] | null> {
-    const cachedData = await cacheAdapter.get(cacheKey)
-
-    if (cachedData) {
-      logger.log(`Dados recuperados do cache: ${cacheKey}`)
-
-      return deserialize(cachedData).map((product: any) => new ProductHasuraGraphQL(product))
-    }
-
-    return null
-  }
-
-  static async saveProductsToCache(params: {
-    cacheAdapter: CacheAdapter
-    cacheKey: string
-    products: Product[]
-    ttl: number
-    logger: DebugHelper
-  }): Promise<void> {
-    const { cacheAdapter, cacheKey, products, ttl, logger } = params
-
-    await cacheAdapter.set({
-      key: cacheKey,
-      data: serialize(products),
-      expirationInSeconds: ttl,
-    })
-
-    logger.log(`Dados salvos no cache: ${cacheKey}`)
-  }
-
-  static shouldUseCache(cacheAdapter: CacheAdapter, optionsCache?: { cache?: RepositoryCacheOptions }): boolean {
-    return !!(cacheAdapter && optionsCache?.cache?.enabled)
-  }
-}

package/src/infra/hasura-graphql/repositories/catalog/helpers/category-filter-operations.helper.ts

@@ -1,148 +0,0 @@
-import { CategoryFilter, Filter, UpdateOptions, UpdateRepositoryParams } from '../../../../../domain'
-import { CategoryHasuraGraphQL } from '../../../models'
-import { CategoryFilterHasuraGraphQLRepository } from '../category-filter-hasura-graphql.repository'
-
-interface FilterUpdateDependencies {
-  categoryFilterRepository: CategoryFilterHasuraGraphQLRepository
-}
-
-interface RemoveFiltersParams {
-  categoryId: number
-  filters: UpdateOptions<Filter[]>
-  dependencies: FilterUpdateDependencies
-}
-
-interface MergeFiltersParams {
-  categoryId: number
-  filters: UpdateOptions<Filter[]>
-  dependencies: FilterUpdateDependencies
-}
-
-interface ReplaceFiltersParams {
-  categoryId: number
-  filters: Filter[]
-  dependencies: FilterUpdateDependencies
-}
-
-interface FilterDeletionParams {
-  categoryId: number
-  filtersToDelete: number[]
-  currentFilters: any[]
-  dependencies: FilterUpdateDependencies
-}
-
-export class CategoryFilterOperationsHelper {
-  static async executeUpdate(
-    categoryId: number,
-    filters: Pick<UpdateRepositoryParams<CategoryHasuraGraphQL>, 'filters'>['filters'],
-    dependencies: FilterUpdateDependencies,
-  ): Promise<Filter[]> {
-    if ('action' in filters && filters.action === 'remove' && filters.value.length) {
-      return this.handleRemoveAction({ categoryId, filters, dependencies })
-    }
-
-    if ('action' in filters && filters.action === 'merge' && filters.value.length) {
-      return this.handleMergeAction({ categoryId, filters, dependencies })
-    }
-
-    if (Array.isArray(filters) && filters.length) {
-      return this.handleReplaceAction({ categoryId, filters, dependencies })
-    }
-
-    return []
-  }
-
-  private static async handleRemoveAction(params: RemoveFiltersParams): Promise<Filter[]> {
-    const { categoryId, filters, dependencies } = params
-
-    for (const filter of filters.value) {
-      await dependencies.categoryFilterRepository.deleteByCategoryAndFilter(categoryId, filter.id)
-    }
-
-    return []
-  }
-
-  private static async handleMergeAction(params: MergeFiltersParams): Promise<Filter[]> {
-    const { categoryId, filters, dependencies } = params
-
-    const currentFilters = await this.getCurrentFilters(categoryId, dependencies)
-    const filterDifferences = this.calculateFilterDifferences(currentFilters, filters.value)
-
-    await this.processFilterDeletions({
-      categoryId,
-      filtersToDelete: filterDifferences.toDelete,
-      currentFilters,
-      dependencies,
-    })
-    await this.processFilterInsertions(categoryId, filterDifferences.toInsert, dependencies)
-
-    return filters.value
-  }
-
-  private static async handleReplaceAction(params: ReplaceFiltersParams): Promise<Filter[]> {
-    const { categoryId, filters, dependencies } = params
-
-    await dependencies.categoryFilterRepository.deleteByCategory(categoryId)
-
-    const createdFilters = []
-
-    for (const filter of filters) {
-      const newCategoryFilter = await dependencies.categoryFilterRepository.create({
-        filterId: filter.id,
-        categoryId,
-      })
-
-      createdFilters.push(newCategoryFilter)
-    }
-
-    return filters
-  }
-
-  private static async getCurrentFilters(categoryId: number, dependencies: FilterUpdateDependencies) {
-    const result = await dependencies.categoryFilterRepository.find({
-      filters: { categoryId },
-    })
-
-    return result.data
-  }
-
-  private static calculateFilterDifferences(
-    currentFilters: CategoryFilter[],
-    updatedFilters: Filter[],
-  ): { toDelete: number[]; toInsert: number[] } {
-    const currentFiltersId = currentFilters.map((f) => f.filterId)
-    const filtersUpdatedId = updatedFilters.map((f) => f.id)
-
-    return {
-      toDelete: currentFiltersId.filter((id) => !filtersUpdatedId.includes(id)),
-      toInsert: filtersUpdatedId.filter((id) => !currentFiltersId.includes(id)),
-    }
-  }
-
-  private static async processFilterDeletions(params: FilterDeletionParams): Promise<void> {
-    const { categoryId, filtersToDelete, currentFilters, dependencies } = params
-
-    for (const filterId of filtersToDelete) {
-      const index = currentFilters.findIndex((f) => f.id === filterId)
-
-      if (index !== -1) {
-        currentFilters.splice(index, 1)
-      }
-
-      await dependencies.categoryFilterRepository.deleteByCategoryAndFilter(categoryId, filterId)
-    }
-  }
-
-  private static async processFilterInsertions(
-    categoryId: number,
-    filtersToInsert: number[],
-    dependencies: FilterUpdateDependencies,
-  ): Promise<void> {
-    for (const filterId of filtersToInsert) {
-      await dependencies.categoryFilterRepository.create({
-        filterId,
-        categoryId,
-      })
-    }
-  }
-}

package/src/infra/hasura-graphql/repositories/catalog/helpers/category-home-operations.helper.ts

@@ -1,87 +0,0 @@
-import { Category, Product, RepositoryCacheOptions, Shops, Where } from '../../../../../domain'
-
-export interface CategoriesForHomeParams {
-  categoryIds: string[]
-  shop: Shops
-  limit?: number
-  optionsCache?: { cache?: RepositoryCacheOptions }
-}
-
-export interface CategoryHomeSection {
-  category: Category
-  products: Product[]
-}
-
-export class CategoryHomeOperationsHelper {
-  static separateCategoryIds(categoryIds: string[]): {
-    firestore: string[]
-    hasura: string[]
-  } {
-    return {
-      firestore: categoryIds.filter((categoryId) => Number.isNaN(+categoryId)),
-      hasura: categoryIds.filter((categoryId) => +categoryId > 0),
-    }
-  }
-
-  static async fetchFirestoreCategories(
-    categoriesFirestore: string[],
-    findFunction: Function,
-    optionsCache?: { cache?: RepositoryCacheOptions },
-  ): Promise<Category[]> {
-    if (!categoriesFirestore.length) return []
-
-    const result = await findFunction(
-      {
-        filters: {
-          firestoreId: { operator: Where.IN, value: categoriesFirestore.filter(Boolean) },
-          published: true,
-        },
-      },
-      optionsCache,
-    )
-
-    return result.data
-  }
-
-  static async fetchHasuraCategories(
-    categoriesHasura: string[],
-    findFunction: Function,
-    optionsCache?: { cache?: RepositoryCacheOptions },
-  ): Promise<Category[]> {
-    if (!categoriesHasura.length) return []
-
-    const result = await findFunction(
-      {
-        filters: {
-          id: { operator: Where.IN, value: categoriesHasura.filter(Boolean) },
-          published: true,
-        },
-      },
-      optionsCache,
-    )
-
-    return result.data
-  }
-
-  static async buildHomeSections(
-    categories: Category[],
-    mountCategoryFunction: Function,
-    params: {
-      shop: Shops
-      limit: number
-      optionsCache?: { cache?: RepositoryCacheOptions }
-    },
-  ): Promise<CategoryHomeSection[]> {
-    return Promise.all(
-      categories.map(async (category) => ({
-        category,
-        products: await mountCategoryFunction({
-          category,
-          shop: params.shop,
-          options: { limit: params.limit, hasStock: true },
-          optionsCache: params.optionsCache,
-        }),
-      })),
-    )
-  }
-}

package/src/infra/hasura-graphql/repositories/catalog/helpers/category-mount-operations.helper.ts

@@ -1,219 +0,0 @@
-import {
-  CacheAdapter,
-  Category,
-  NonFunctionPropertyNames,
-  Product,
-  RepositoryCacheOptions,
-  Shops,
-} from '../../../../../domain'
-import { DebugHelper } from '../../../../../utils'
-import { ProductHasuraGraphQL } from '../../../models'
-import { ProductHasuraGraphQLRepository } from '../product-hasura-graphql.repository'
-
-import { CategoryCacheOperationsHelper } from './category-cache-operations.helper'
-import { CategoryProductOperationsHelper, MountCategoryParams } from './category-product-operations.helper'
-
-interface MountCategoryDependencies {
-  productRepository: ProductHasuraGraphQLRepository
-  cacheAdapter?: CacheAdapter
-  defaultCacheTtl: number
-  logger: DebugHelper
-}
-
-interface CacheCheckParams {
-  category: Category
-  shop: Shops
-  options: { limit?: number; hasStock?: boolean }
-  optionsCache: { cache?: RepositoryCacheOptions }
-  dependencies: MountCategoryDependencies
-}
-
-interface FetchMostRelevantsParams {
-  mostRelevantsIds: string[]
-  fields: NonFunctionPropertyNames<ProductHasuraGraphQL>[]
-  shop: Shops
-  options: { limit?: number; hasStock?: boolean }
-  optionsCache: { cache?: RepositoryCacheOptions }
-  dependencies: MountCategoryDependencies
-}
-
-interface FinalizeWithMostRelevantsParams {
-  mostRelevantProducts: ProductHasuraGraphQL[]
-  mostRelevantsIds: string[]
-  category: Category
-  shop: Shops
-  options: { limit?: number; hasStock?: boolean }
-  optionsCache: { cache?: RepositoryCacheOptions }
-  dependencies: MountCategoryDependencies
-}
-
-interface FinalizeWithAllProductsParams {
-  category: Category
-  mostRelevantProducts: ProductHasuraGraphQL[]
-  mostRelevantsIds: string[]
-  fields: NonFunctionPropertyNames<ProductHasuraGraphQL>[]
-  shop: Shops
-  options: { limit?: number; hasStock?: boolean }
-  optionsCache: { cache?: RepositoryCacheOptions }
-  dependencies: MountCategoryDependencies
-}
-
-interface CacheSaveParams {
-  category: Category
-  shop: Shops
-  options: { limit?: number; hasStock?: boolean }
-  optionsCache: { cache?: RepositoryCacheOptions }
-  result: Product[]
-  dependencies: MountCategoryDependencies
-}
-
-export class CategoryMountOperationsHelper {
-  static async executeMount(params: MountCategoryParams, dependencies: MountCategoryDependencies): Promise<Product[]> {
-    const { category, shop, options = {}, optionsCache } = params
-
-    if (!category?.products?.length) return []
-
-    const cachedResult = await this.tryGetFromCache({
-      category,
-      shop,
-      options,
-      optionsCache,
-      dependencies,
-    })
-
-    if (cachedResult) return cachedResult
-
-    const fields = CategoryProductOperationsHelper.getProductFields()
-    const mostRelevantsIds = category.getMostRelevantByShop(shop)
-
-    const mostRelevantProducts = await this.fetchMostRelevantProducts({
-      mostRelevantsIds,
-      fields,
-      shop,
-      options,
-      optionsCache,
-      dependencies,
-    })
-
-    if (mostRelevantProducts.length >= mostRelevantsIds.length) {
-      return this.finalizeMountWithMostRelevants({
-        mostRelevantProducts,
-        mostRelevantsIds,
-        category,
-        shop,
-        options,
-        optionsCache,
-        dependencies,
-      })
-    }
-
-    return this.finalizeMountWithAllProducts({
-      category,
-      mostRelevantProducts,
-      mostRelevantsIds,
-      fields,
-      shop,
-      options,
-      optionsCache,
-      dependencies,
-    })
-  }
-
-  private static async tryGetFromCache(params: CacheCheckParams): Promise<Product[] | null> {
-    const { category, shop, options, optionsCache, dependencies } = params
-    const shouldUseCache = CategoryCacheOperationsHelper.shouldUseCache(dependencies.cacheAdapter, optionsCache)
-
-    if (!shouldUseCache) return null
-
-    const cacheKey = CategoryCacheOperationsHelper.generateCacheKey(category, shop, options)
-
-    return CategoryCacheOperationsHelper.getCachedProducts(dependencies.cacheAdapter, cacheKey, dependencies.logger)
-  }
-
-  private static async fetchMostRelevantProducts(params: FetchMostRelevantsParams): Promise<Product[]> {
-    const { mostRelevantsIds, fields, shop, options, optionsCache, dependencies } = params
-
-    return CategoryProductOperationsHelper.fetchMostRelevantProducts({
-      productRepository: dependencies.productRepository,
-      mostRelevantsIds,
-      fields,
-      shop,
-      hasStock: options.hasStock,
-      optionsCache,
-    })
-  }
-
-  private static async finalizeMountWithMostRelevants(
-    params: FinalizeWithMostRelevantsParams,
-  ): Promise<ProductHasuraGraphQL[]> {
-    const { mostRelevantProducts, mostRelevantsIds, category, shop, options, optionsCache, dependencies } = params
-
-    const result = CategoryProductOperationsHelper.reorganizeMostRelevantsProducts(
-      mostRelevantProducts,
-      mostRelevantsIds,
-      options.limit,
-    )
-
-    await this.saveToCacheIfNeeded({
-      category,
-      shop,
-      options,
-      optionsCache,
-      result,
-      dependencies,
-    })
-
-    return result
-  }
-
-  private static async finalizeMountWithAllProducts(
-    params: FinalizeWithAllProductsParams,
-  ): Promise<ProductHasuraGraphQL[]> {
-    const { category, mostRelevantProducts, mostRelevantsIds, fields, shop, options, optionsCache, dependencies } =
-      params
-
-    const regularProductIds = category.products.filter((productId) => !mostRelevantsIds.includes(productId))
-    const regularProducts = await CategoryProductOperationsHelper.fetchRegularProducts({
-      productRepository: dependencies.productRepository,
-      productIds: regularProductIds,
-      fields,
-      shop,
-      options,
-      optionsCache,
-    })
-
-    const result = CategoryProductOperationsHelper.reorganizeMostRelevantsProducts(
-      [...mostRelevantProducts, ...regularProducts],
-      mostRelevantsIds,
-      options.limit,
-    )
-
-    await this.saveToCacheIfNeeded({
-      category,
-      shop,
-      options,
-      optionsCache,
-      result,
-      dependencies,
-    })
-
-    return result
-  }
-
-  private static async saveToCacheIfNeeded(params: CacheSaveParams): Promise<void> {
-    const { category, shop, options, optionsCache, result, dependencies } = params
-    const shouldUseCache = CategoryCacheOperationsHelper.shouldUseCache(dependencies.cacheAdapter, optionsCache)
-
-    if (!shouldUseCache) return
-
-    const cacheKey = CategoryCacheOperationsHelper.generateCacheKey(category, shop, options)
-
-    await CategoryCacheOperationsHelper.saveProductsToCache({
-      cacheAdapter: dependencies.cacheAdapter,
-      cacheKey,
-      products: result,
-      ttl: optionsCache?.cache?.ttl || dependencies.defaultCacheTtl,
-      logger: dependencies.logger,
-    })
-  }
-}

package/src/infra/hasura-graphql/repositories/catalog/helpers/category-product-operations.helper.ts

@@ -1,154 +0,0 @@
-import {
-  Category,
-  FindRepositoryParams,
-  NonFunctionPropertyNames,
-  ProductRepository,
-  RepositoryCacheOptions,
-  Shops,
-  Where,
-} from '../../../../../domain'
-import { ProductHasuraGraphQL } from '../../../models'
-
-export interface MountCategoryParams {
-  category: Category
-  shop: Shops
-  options?: { limit?: number; hasStock?: boolean; gender?: string }
-  optionsCache?: { cache?: RepositoryCacheOptions }
-}
-
-export interface ProductSearchFilters {
-  id: { operator: Where; value: string[] }
-  published: boolean
-  stock?: { quantity: { operator: Where; value: number } }
-}
-
-export class CategoryProductOperationsHelper {
-  static getProductFields(): NonFunctionPropertyNames<ProductHasuraGraphQL>[] {
-    return [
-      'id',
-      'name',
-      'slug',
-      'images',
-      'miniatures',
-      'price',
-      'fullPrice',
-      'subscriberDiscountPercentage',
-      'subscriberPrice',
-      'stock',
-      'published',
-      'CEST',
-      'EAN',
-      'NCM',
-      'brand',
-      'costPrice',
-      'hasVariants',
-      'isKit',
-      'sku',
-      'rate',
-      'tags',
-      'type',
-      'shoppingCount',
-      'gender',
-      'createdAt',
-      'label',
-      'outlet',
-    ]
-  }
-
-  static buildProductFilters(productIds: string[], hasStock?: boolean): ProductSearchFilters {
-    const filters: ProductSearchFilters = {
-      id: { operator: Where.IN, value: productIds },
-      published: true,
-    }
-
-    if (hasStock) {
-      filters.stock = { quantity: { operator: Where.GT, value: 0 } }
-    }
-
-    return filters
-  }
-
-  static buildProductQuery(params: {
-    productIds: string[]
-    fields: NonFunctionPropertyNames<ProductHasuraGraphQL>[]
-    hasStock?: boolean
-    limit?: number
-  }): FindRepositoryParams<ProductHasuraGraphQL> {
-    const { productIds, fields, hasStock, limit } = params
-
-    return {
-      filters: this.buildProductFilters(productIds, hasStock),
-      ...(limit ? { limits: { limit } } : {}),
-      fields,
-      options: { enableCount: false },
-      orderBy: {
-        stock: 'desc',
-        shoppingCount: 'desc',
-        rate: 'desc',
-        name: 'asc',
-      },
-    }
-  }
-
-  static getGenderParam(shop: Shops): 'male' | 'female' {
-    return shop === Shops.MENSMARKET ? 'male' : 'female'
-  }
-
-  static async fetchMostRelevantProducts(params: {
-    productRepository: ProductRepository
-    mostRelevantsIds: string[]
-    fields: NonFunctionPropertyNames<ProductHasuraGraphQL>[]
-    shop: Shops
-    hasStock?: boolean
-    optionsCache?: { cache?: RepositoryCacheOptions }
-  }): Promise<ProductHasuraGraphQL[]> {
-    const { productRepository, mostRelevantsIds, fields, shop, hasStock, optionsCache } = params
-
-    if (!mostRelevantsIds?.length) return []
-
-    const query = this.buildProductQuery({ productIds: mostRelevantsIds, fields, hasStock })
-    const { data } = await productRepository.findCatalog(query, this.getGenderParam(shop), optionsCache)
-
-    return data
-  }
-
-  static async fetchRegularProducts(params: {
-    productRepository: ProductRepository
-    productIds: string[]
-    fields: NonFunctionPropertyNames<ProductHasuraGraphQL>[]
-    shop: Shops
-    options: { hasStock?: boolean; limit?: number }
-    optionsCache?: { cache?: RepositoryCacheOptions }
-  }): Promise<ProductHasuraGraphQL[]> {
-    const { productRepository, productIds, fields, shop, options, optionsCache } = params
-
-    if (!productIds.length) return []
-
-    const query = this.buildProductQuery({ productIds, fields, hasStock: options.hasStock, limit: options.limit })
-    const { data } = await productRepository.findCatalog(query, this.getGenderParam(shop), optionsCache)
-
-    return data
-  }
-
-  static reorganizeMostRelevantsProducts(
-    products: ProductHasuraGraphQL[],
-    mostRelevantsIds: string[],
-    limit?: number,
-  ): ProductHasuraGraphQL[] {
-    const mostRelevantWithoutStock = products.filter(
-      (product) => mostRelevantsIds.includes(product.id) && product.stock.quantity <= 0,
-    )
-
-    const firstProducts = products
-      .filter((product) => mostRelevantsIds.includes(product.id) && product.stock.quantity > 0)
-      .sort((a, b) => mostRelevantsIds.indexOf(a.id) - mostRelevantsIds.indexOf(b.id))
-
-    const lastProducts = products
-      .filter((product) => !mostRelevantsIds.includes(product.id) && product.stock.quantity > 0)
-      .concat(mostRelevantWithoutStock)
-
-    const categoryMostRelevants = firstProducts.concat(lastProducts)
-
-    return limit ? categoryMostRelevants.slice(0, limit) : categoryMostRelevants
-  }
-}

package/src/infra/hasura-graphql/repositories/catalog/helpers/index.ts

@@ -1,10 +0,0 @@
-export * from './category-cache-operations.helper'
-export * from './category-filter-operations.helper'
-export * from './category-home-operations.helper'
-export * from './category-mount-operations.helper'
-export * from './category-product-operations.helper'
-export * from './product-fetch-reviews.helper'
-export * from './product-review-cache.helper'
-export * from './product-review-operations.helper'
-export * from './product-review-update.helper'
-export * from './product-variant-report.helper'