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

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

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

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

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

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

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

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

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