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

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

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

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

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

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

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

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

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