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

package/src/infra/hasura-graphql/repositories/catalog/helpers/product-fetch-reviews.helper.ts

@@ -1,79 +0,0 @@
-import { ProductReview, ReviewStatusParams, ReviewWithProductData } from '../../../../../domain'
-import { HasuraGraphQLWhere } from '../../../enums'
-import { ProductHasuraGraphQL } from '../../../models'
-
-interface FetchReviewsDependencies {
-  query: (table: string, fields: any, params?: any) => Promise<any>
-  bindReviewToModel: (plain: any) => ProductReview
-  reviewsFields: any
-}
-
-export class ProductFetchReviewsHelper {
-  static buildReviewsExpression(status: ReviewStatusParams): any {
-    return {
-      status:
-        status === 'pending'
-          ? { [HasuraGraphQLWhere.ISNULL]: true }
-          : { [HasuraGraphQLWhere.EQUALS]: status === 'approved' },
-    }
-  }
-
-  static async fetchProductsWithReviews(
-    status: ReviewStatusParams,
-    dependencies: FetchReviewsDependencies,
-  ): Promise<any[]> {
-    const reviewsExpression = this.buildReviewsExpression(status)
-
-    const { product: data } = await dependencies.query(
-      'product',
-      ['id', 'name', 'sku', { reviews: { columnName: 'reviews', fields: dependencies.reviewsFields } }],
-      {
-        where: { value: { reviews: reviewsExpression }, type: 'product_bool_exp', required: true },
-      },
-    )
-
-    return data
-  }
-
-  static processReviewsData(
-    data: Array<
-      Omit<ProductHasuraGraphQL, 'reviews'> & {
-        reviews: Array<Record<'person_id' | 'order_id' | 'created_at' | 'updated_at' | 'status', any>>
-      }
-    >,
-    status: ReviewStatusParams,
-    bindReviewToModel: (plain: any) => ProductReview,
-  ): ReviewWithProductData[] {
-    return data.reduce(
-      (reviews: ReviewWithProductData[], product) => [
-        ...reviews,
-        ...product.reviews
-          .filter((review) => this.matchesStatus(review, status))
-          .map((review) => ({
-            ...bindReviewToModel(review),
-            productId: product.id,
-            productName: product.name,
-            productSku: product.sku,
-          })),
-      ],
-      [] as ReviewWithProductData[],
-    )
-  }
-
-  private static matchesStatus(review: any, status: ReviewStatusParams): boolean {
-    return (
-      (status === 'pending' && [undefined, null].includes(review.status)) ||
-      (status === 'approved' && review.status === true) ||
-      (status === 'rejected' && review.status === false)
-    )
-  }
-
-  static async executeQuery(
-    status: ReviewStatusParams,
-    dependencies: FetchReviewsDependencies,
-  ): Promise<ReviewWithProductData[]> {
-    const data = await this.fetchProductsWithReviews(status, dependencies)
-
-    return this.processReviewsData(data, status, dependencies.bindReviewToModel)
-  }
-}

package/src/infra/hasura-graphql/repositories/catalog/helpers/product-review-cache.helper.ts

@@ -1,76 +0,0 @@
-import {
-  PaginatedReviewFilters,
-  ProductReview,
-  RepositoryCacheOptions,
-  ReviewStatusParams,
-  ReviewWithProductData,
-} from '../../../../../domain'
-import { deserialize, serialize } from '../../../../../utils'
-import { MD5GeneratorHelper } from '../../../mixins/helpers'
-
-interface CacheOperationDependencies {
-  cacheAdapter: any
-  logger: any
-  modelName: string
-  defaultTtl: number
-}
-
-interface CacheCheckParams {
-  key: string
-  dependencies: CacheOperationDependencies
-}
-
-interface CacheSaveParams {
-  key: string
-  data: any
-  ttl?: number
-  dependencies: CacheOperationDependencies
-}
-
-export class ProductReviewCacheHelper {
-  static generateProductReviewsCacheKey(filters: PaginatedReviewFilters, modelName: string): string {
-    return `${modelName.toLowerCase()}:all-reviews:${MD5GeneratorHelper.generateMD5(filters)}`
-  }
-
-  static generateReviewsStatusCacheKey(status: ReviewStatusParams, modelName: string): string {
-    return `${modelName.toLowerCase()}:reviews:${status}`
-  }
-
-  static generateProductReviewsCacheKeyForProduct(productId: number, modelName: string): string {
-    return `${modelName.toLowerCase()}:reviews:product:${productId}`
-  }
-
-  static async tryGetFromCache(params: CacheCheckParams): Promise<ReviewWithProductData[] | ProductReview[] | null> {
-    const { key, dependencies } = params
-
-    if (!dependencies.cacheAdapter) return null
-
-    const cachedData = await dependencies.cacheAdapter.get(key)
-
-    if (cachedData) {
-      dependencies.logger.log(`Dados recuperados do cache: ${key}`)
-
-      return deserialize(cachedData).map((review: any) => new ProductReview(review))
-    }
-
-    return null
-  }
-
-  static async saveToCache(params: CacheSaveParams): Promise<void> {
-    const { key, data, ttl, dependencies } = params
-
-    if (!dependencies.cacheAdapter) return
-
-    await dependencies.cacheAdapter.set({
-      key,
-      data: serialize(data),
-      expirationInSeconds: ttl || dependencies.defaultTtl,
-    })
-
-    dependencies.logger.log(`Dados salvos no cache: ${key}`)
-  }
-
-  static shouldUseCache(cacheAdapter: any, options?: { cache?: RepositoryCacheOptions }): boolean {
-    return !!(cacheAdapter && options?.cache?.enabled)
-  }
-}

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

@@ -1,90 +0,0 @@
-import { PaginatedReviewFilters, ProductReview, ReviewWithProductData } from '../../../../../domain'
-import { ProductHasuraGraphQL } from '../../../models'
-
-interface ReviewDataFetchParams {
-  repository: any
-  limit: number
-}
-
-interface ReviewProcessingParams {
-  data: ProductHasuraGraphQL[]
-  getReviewStatus: (review: ProductReview) => 'approved' | 'rejected' | 'pending'
-}
-
-interface ReviewFilteringParams {
-  reviews: ReviewWithProductData[]
-  filters: PaginatedReviewFilters
-}
-
-export class ProductReviewOperationsHelper {
-  static async fetchAllProductsWithReviews(params: ReviewDataFetchParams): Promise<ProductHasuraGraphQL[]> {
-    const { repository, limit } = params
-    let data: ProductHasuraGraphQL[] = []
-    let count = 0
-    let offset = 0
-
-    do {
-      const result = await repository.find({
-        fields: ['id', 'name', 'sku', 'reviews'],
-        ...(limit && {
-          limits: { offset, limit },
-        }),
-      })
-
-      data = data.concat(result.data)
-      count = result.data.length
-      offset += limit
-    } while (count === limit)
-
-    return data
-  }
-
-  static processProductsToReviews(params: ReviewProcessingParams): ReviewWithProductData[] {
-    const { data, getReviewStatus } = params
-
-    return data.reduce(
-      (reviews, product) => [
-        ...reviews,
-        ...product.reviews.map((review) => ({
-          ...review,
-          reviewStatus: getReviewStatus(review),
-          productId: product.id,
-          productName: product.name,
-          productSku: product.sku,
-        })),
-      ],
-      [] as ReviewWithProductData[],
-    )
-  }
-
-  static applyReviewFilters(params: ReviewFilteringParams): ReviewWithProductData[] {
-    const { reviews, filters } = params
-    let filteredReviews = reviews
-
-    if (filters.sku) {
-      filteredReviews = filteredReviews.filter((review) => review.productSku === filters.sku)
-    }
-
-    if (filters.status) {
-      filteredReviews = filteredReviews.filter((review) => review.reviewStatus === filters.status)
-    }
-
-    if (filters.email) {
-      filteredReviews = filteredReviews.filter((review) => review.email === filters.email)
-    }
-
-    if (filters.rate) {
-      filteredReviews = filteredReviews.filter((review) => review.rate === filters.rate)
-    }
-
-    if (filters.period) {
-      filteredReviews = filteredReviews.filter((review) => {
-        const reviewDate = new Date(review.createdAt)
-
-        return reviewDate >= filters.period.start && reviewDate <= filters.period.end
-      })
-    }
-
-    return filteredReviews
-  }
-}

package/src/infra/hasura-graphql/repositories/catalog/helpers/product-review-update.helper.ts

@@ -1,121 +0,0 @@
-import { NonFunctionPropertyNames, ProductReview, UpdateOptions, UpdateRepositoryParams } from '../../../../../domain'
-import { omit } from '../../../../../utils'
-import { UpdateHasuraGraphQLRepositoryType } from '../../../mixins'
-import { ProductHasuraGraphQL } from '../../../models'
-import { GraphQLRepository } from '../../../types'
-
-interface ReviewUpdateDependencies {
-  mutation: GraphQLRepository<ProductHasuraGraphQL>['mutation']
-  findReview: (review: ProductReview, productId: number) => Promise<ProductReview>
-  bindReviewToModel: (plain: Record<'person_id' | 'order_id' | 'created_at' | 'updated_at', any>) => ProductReview
-  bindReviewToHasura: (review: ProductReview) => any
-  reviewsFields: NonFunctionPropertyNames<ProductHasuraGraphQL>[]
-  paramsToPlain: UpdateHasuraGraphQLRepositoryType<ProductHasuraGraphQL>['paramsToPlain']
-}
-
-interface RemoveReviewsParams {
-  productId: number
-  reviews: UpdateOptions<ProductReview[]>
-  dependencies: ReviewUpdateDependencies
-}
-
-interface UpsertReviewsParams {
-  productId: number
-  reviews: ProductReview[]
-  dependencies: ReviewUpdateDependencies
-}
-
-export class ProductReviewUpdateHelper {
-  static async executeUpdate(
-    productId: number,
-    reviews: Pick<UpdateRepositoryParams<ProductHasuraGraphQL>, 'reviews'>['reviews'],
-    dependencies: ReviewUpdateDependencies,
-  ): Promise<ProductReview[]> {
-    if (!reviews) return []
-
-    if ('action' in reviews && reviews.action === 'remove') {
-      return this.handleRemoveReviews({ productId, reviews, dependencies })
-    }
-
-    const plainData = dependencies.paramsToPlain({ reviews })
-
-    if (!plainData.reviews || plainData.reviews.length <= 0) return []
-
-    return this.handleUpsertReviews({ productId, reviews: plainData.reviews, dependencies })
-  }
-
-  private static async handleRemoveReviews(params: RemoveReviewsParams): Promise<ProductReview[]> {
-    const { productId, reviews, dependencies } = params
-
-    const reviewIds = await Promise.all(
-      reviews.value.map(async (reviewData) => {
-        const review = await dependencies.findReview(reviewData, productId)
-
-        return review?.id
-      }),
-    )
-
-    await dependencies.mutation('delete_product_review', ['affected_rows'], {
-      where: {
-        value: { id: { _in: reviewIds.filter(Boolean) } },
-        type: 'product_review_bool_exp',
-        required: true,
-      },
-    })
-
-    return reviews.value.map((review, index) => !reviewIds[index] && review).filter(Boolean)
-  }
-
-  private static async handleUpsertReviews(params: UpsertReviewsParams): Promise<ProductReview[]> {
-    const { productId, reviews, dependencies } = params
-
-    return Promise.all(
-      reviews.map(async (reviewData) => {
-        const review = await dependencies.findReview(reviewData, productId)
-
-        if (review.id) {
-          return this.updateExistingReview(review.id.toString(), reviewData, dependencies)
-        }
-
-        return this.insertNewReview(reviewData, productId, dependencies)
-      }),
-    )
-  }
-
-  private static async updateExistingReview(
-    reviewId: string,
-    reviewData: ProductReview,
-    dependencies: ReviewUpdateDependencies,
-  ): Promise<ProductReview> {
-    const result = await dependencies.mutation('update_product_review_by_pk', dependencies.reviewsFields, {
-      pk_columns: {
-        value: { id: reviewId },
-        type: 'product_review_pk_columns_input',
-        required: true,
-      },
-      _set: {
-        value: omit(dependencies.bindReviewToHasura(reviewData), ['id', 'product_id']),
-        type: 'product_review_set_input',
-        required: true,
-      },
-    })
-
-    return dependencies.bindReviewToModel(result.update_product_review_by_pk)
-  }
-
-  private static async insertNewReview(
-    reviewData: ProductReview,
-    productId: number,
-    dependencies: ReviewUpdateDependencies,
-  ): Promise<ProductReview> {
-    const result = await dependencies.mutation('insert_product_review_one', dependencies.reviewsFields, {
-      object: {
-        value: omit({ ...dependencies.bindReviewToHasura(reviewData), product_id: productId.toString() }, ['id']),
-        type: 'product_review_insert_input',
-        required: true,
-      },
-    })
-
-    return dependencies.bindReviewToModel(result.insert_product_review_one)
-  }
-}

package/src/infra/hasura-graphql/repositories/catalog/helpers/product-variant-report.helper.ts

@@ -1,65 +0,0 @@
-import { ProductVariantReport } from '../../../../../domain'
-
-interface VariantReportDependencies {
-  query: (table: string, fields: string[]) => Promise<any>
-}
-
-export class ProductVariantReportHelper {
-  static getReportFields(): string[] {
-    return [
-      'id',
-      'name',
-      'description',
-      'slug',
-      'sku',
-      'ean',
-      'cest',
-      'ncm',
-      'has_variants',
-      'is_variant',
-      'grade',
-      'type',
-      'is_kit',
-      'tags',
-      'published',
-      'stock',
-      'brand',
-      'brand_description',
-      'images',
-      'miniatures',
-      'video',
-      'weight',
-      'cost_price',
-      'full_price',
-      'price',
-      'subscriber_discount_percentage',
-      'subscriber_price',
-      'how_to_use',
-      'who_must_use',
-      'differentials',
-      'ingredients',
-      'purpose',
-      'filters',
-      'category_id',
-      'outlet',
-      'label',
-      'group',
-      'validity',
-      'gender',
-      'shopping_count',
-      'rating',
-      'reviews_total',
-      'created_at',
-      'updated_at',
-    ]
-  }
-
-  static async executeReport(dependencies: VariantReportDependencies): Promise<ProductVariantReport[]> {
-    const fields = this.getReportFields()
-
-    const { product_variant_report_query: data }: { product_variant_report_query: ProductVariantReport[] } =
-      await dependencies.query('product_variant_report_query', fields)
-
-    return data
-  }
-}

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

@@ -1,12 +0,0 @@
-export * from './category-collection-children-hasura-graphql.repository'
-export * from './category-filter-hasura-graphql.repository'
-export * from './category-hasura-graphql.repository'
-export * from './category-product-hasura-graphql.repository'
-export * from './filter-hasura-graphql.repository'
-export * from './filter-option-hasura-graphql.repository'
-export * from './product-errors-hasura-graphql.repository'
-export * from './product-hasura-graphql.repository'
-export * from './product-review-hasura-graphql.repository'
-export * from './product-stock-notification-hasura-graphql.repository'
-export * from './variant-hasura-graphql.repository'
-export * from './wishlist-hasura-graphql.repository'

package/src/infra/hasura-graphql/repositories/catalog/product-errors-hasura-graphql.repository.ts

@@ -1,104 +0,0 @@
-import { FindRepositoryParams, GetRepositoryParams, Where } from '../../../../domain'
-import { ProductErrorsRepository } from '../../../../domain/catalog/repositories'
-import { Base, isEmpty } from '../../../../utils'
-import { HasuraConstructorParams, withCrudHasuraGraphQL, withHasuraGraphQL } from '../../mixins'
-import { ProductErrorsHasuraGraphQL, VariantHasuraGraphQL } from '../../models'
-
-import { ProductHasuraGraphQLRepository } from './product-hasura-graphql.repository'
-
-export class ProductErrorsHasuraGraphQLRepository
-  extends withCrudHasuraGraphQL(withHasuraGraphQL<ProductErrorsHasuraGraphQL>(Base))
-  implements ProductErrorsRepository
-{
-  constructor(
-    {
-      endpoint,
-      authOptions,
-      interceptors,
-      cache,
-    }: Pick<HasuraConstructorParams<ProductErrorsHasuraGraphQL>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>,
-    private readonly productRepository: ProductHasuraGraphQLRepository,
-  ) {
-    super({
-      tableName: 'product_errors',
-      model: ProductErrorsHasuraGraphQL,
-      endpoint,
-      authOptions,
-      interceptors,
-      cache,
-      fields: [
-        {
-          productId: {
-            columnName: 'product_id',
-            to: (value: string) => +value,
-            from: (value: number) => value.toString(),
-          },
-        },
-        'source',
-        'error',
-        { createdAt: { columnName: 'created_at' } },
-        { updatedAt: { columnName: 'updated_at' } },
-        {
-          product: {
-            columnName: 'product',
-            foreignKeyColumn: { id: 'productId' },
-            fields: [
-              { id: { columnName: 'id', from: (value: number) => value.toString() } },
-              { productId: { columnName: 'main_product_id' } },
-              'name',
-              'published',
-              'group',
-              'validity',
-              { createdAt: { columnName: 'created_at' } },
-              { updatedAt: { columnName: 'updated_at' } },
-            ],
-          },
-        },
-      ],
-    })
-  }
-
-  override async get(params: GetRepositoryParams<ProductErrorsHasuraGraphQL>) {
-    const result = await super.get(params)
-
-    if (result instanceof VariantHasuraGraphQL) {
-      const product = await this.productRepository.get({ id: result.productId.toString() })
-
-      result.product.name = product.name
-      result.product.group = product.group
-    }
-
-    return result
-  }
-
-  override async find(params: FindRepositoryParams<ProductErrorsHasuraGraphQL>) {
-    const result = await super.find(params)
-    const variantsWithNoData = result.data.filter(
-      (item) =>
-        item.product instanceof VariantHasuraGraphQL &&
-        (isEmpty(item.product.name) || isEmpty(item.product.group) || isEmpty(item.product)),
-    )
-
-    if (variantsWithNoData.length > 0) {
-      const { data: products } = await this.productRepository.find({
-        filters: {
-          id: {
-            operator: Where.IN,
-            value: Array.from(new Set(variantsWithNoData.map((item) => item.product.productId?.toString()))),
-          },
-        },
-      })
-
-      products.forEach((product) => {
-        result.data
-          .filter((variant) => variant.product.productId?.toString() === product.id.toString())
-          .forEach((variant) => {
-            variant.product.name = product.name
-            variant.product.group = product.group
-          })
-      })
-    }
-
-    return result
-  }
-}