@infrab4a/connect 5.7.2 → 5.7.3

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,16 @@
+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-catalog-hasura-graphql.repository'
+export * from './product-errors-hasura-graphql.repository'
+export * from './product-group-hasura-graphql.repository'
+export * from './product-hasura-graphql.repository'
+export * from './product-price-log-hasura-graphql.repository'
+export * from './product-review-hasura-graphql.repository'
+export * from './product-stock-entry-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-catalog-hasura-graphql.repository.ts

@@ -0,0 +1,360 @@
+import {
+  FindRepositoryParams,
+  NonFunctionPropertyNames,
+  Product,
+  ProductCatalogRepository,
+  ProductGender,
+  RepositoryCacheOptions,
+  RepositoryFindResult,
+  RoundProductPricesHelper,
+  ShopPrice,
+} from '../../../../domain'
+import { NotFoundError } from '../../../../errors'
+import { Base, deserialize, isNil, Log, omit, serialize } from '../../../../utils'
+import { HasuraGraphQLColumnType } from '../../enums'
+import { HasuraConstructorParams, withFindHasuraGraphQL, withHasuraGraphQL } from '../../mixins'
+import { ProductCatalogHasuraGraphQL, ProductHasuraGraphQL } from '../../models'
+import { HasuraGraphQLFields } from '../../types'
+
+const commonFields: HasuraGraphQLFields<ProductCatalogHasuraGraphQL> = [
+  {
+    id: {
+      columnName: 'id',
+      to: (value: string) => +value,
+      from: (value) => value.toString(),
+    },
+  },
+  { firestoreId: { columnName: 'firestore_id' } },
+  { productId: { columnName: 'main_product_id' } },
+  { CEST: { columnName: 'cest' } },
+  { EAN: { columnName: 'ean' } },
+  { NCM: { columnName: 'ncm' } },
+  'brand',
+  { costPrice: { columnName: 'cost_price' } },
+  {
+    description: {
+      columnName: 'description',
+      from: (description, data) => ({
+        description,
+        differentials: data.differentials,
+        whoMustUse: data.who_must_use,
+        howToUse: data.how_to_use,
+        brand: data.brand_description,
+        ingredients: data.ingredients,
+        purpose: data.purpose,
+      }),
+      bindFindFilter: (filters: any) => {
+        return {
+          ...(filters?.description && { description: filters.description }),
+          ...(filters.differentials && { differentials: filters.differentials }),
+          ...(filters.whoMustUse && {
+            who_must_use: filters.whoMustUse,
+          }),
+          ...(filters.howToUse && {
+            how_to_use: filters.howToUse,
+          }),
+          ...(filters.brand && {
+            brand_description: filters.brand,
+          }),
+          ...(filters.ingredients && {
+            ingredients: filters.ingredients,
+          }),
+          ...(filters.purpose && {
+            purpose: filters.purpose,
+          }),
+        }
+      },
+      bindPersistData: (descriptionData: ProductHasuraGraphQL['description']) => ({
+        ...(descriptionData?.description && { description: descriptionData.description }),
+        ...(descriptionData.differentials && { differentials: descriptionData.differentials }),
+        ...(descriptionData.whoMustUse && {
+          who_must_use: descriptionData.whoMustUse,
+        }),
+        ...(descriptionData.howToUse && { how_to_use: descriptionData.howToUse }),
+        ...(descriptionData.brand && { brand_description: descriptionData.brand }),
+        ...(descriptionData.ingredients && { ingredients: descriptionData.ingredients }),
+        ...(descriptionData.purpose && { purpose: descriptionData.purpose }),
+      }),
+    },
+  },
+  { differentials: { columnName: 'differentials' } },
+  { whoMustUse: { columnName: 'who_must_use' } },
+  { howToUse: { columnName: 'how_to_use' } },
+  { brandDescription: { columnName: 'brand_description' } },
+  { ingredients: { columnName: 'ingredients' } },
+  { purpose: { columnName: 'purpose' } },
+  { hasVariants: { columnName: 'has_variants' } },
+  {
+    images: {
+      columnName: 'images',
+      to: (value: string[]) => (value?.length > 0 ? `{"${value?.join?.('","') || ''}"}` : '{}'),
+    },
+  },
+  {
+    miniatures: {
+      columnName: 'miniatures',
+      to: (value: string[]) => (value?.length > 0 ? `{"${value?.join?.('","') || ''}"}` : '{}'),
+    },
+  },
+  {
+    imagesCard: {
+      columnName: 'images_card',
+      to: (value: string[]) => (value?.length > 0 ? `{"${value?.join?.('","') || ''}"}` : '{}'),
+    },
+  },
+  'name',
+  {
+    price: {
+      columnName: 'price',
+      from: (price, data): ShopPrice => ({
+        price,
+        fullPrice: data.full_price,
+        subscriberDiscountPercentage: data.subscriber_discount_percentage,
+        fullPriceDiscountPercentage: data.full_price_discount_percentage,
+        subscriberPrice: data.subscriber_price,
+      }),
+      bindFindFilter: (filters: any) => {
+        return {
+          ...((filters?.price || filters?.price === 0) && { price: filters.price }),
+          ...((filters.fullPrice || filters.fullPrice === 0) && { full_price: filters.fullPrice }),
+          ...((filters.subscriberDiscountPercentage || filters.subscriberDiscountPercentage === 0) && {
+            subscriber_discount_percentage: filters.subscriberDiscountPercentage,
+          }),
+          ...((filters.subscriberPrice || filters.subscriberPrice === 0) && {
+            subscriber_price: filters.subscriberPrice,
+          }),
+          ...((filters.fullPriceDiscountPercentage || filters.fullPriceDiscountPercentage === 0) && {
+            full_price_discount_percentage: filters.fullPriceDiscountPercentage,
+          }),
+        }
+      },
+      bindPersistData: (priceData: ProductHasuraGraphQL['price']) => ({
+        ...(priceData?.price >= 0 && { price: priceData.price }),
+        ...(priceData.fullPrice >= 0 && { full_price: priceData.fullPrice }),
+        ...(priceData.subscriberDiscountPercentage >= 0 && {
+          subscriber_discount_percentage: priceData.subscriberDiscountPercentage,
+        }),
+        ...(priceData.subscriberPrice >= 0 && { subscriber_price: priceData.subscriberPrice }),
+        ...(priceData.fullPriceDiscountPercentage >= 0 && {
+          full_price_discount_percentage: priceData.fullPriceDiscountPercentage,
+        }),
+      }),
+    },
+  },
+  { fullPrice: { columnName: 'full_price' } },
+  { subscriberDiscountPercentage: { columnName: 'subscriber_discount_percentage' } },
+  { fullPriceDiscountPercentage: { columnName: 'full_price_discount_percentage' } },
+  { subscriberPrice: { columnName: 'subscriber_price' } },
+  'published',
+  'outlet',
+  'label',
+  'sku',
+  {
+    stock: {
+      columnName: 'stock',
+      from: (quantity: number) => ({ quantity }),
+      to: (value: ProductHasuraGraphQL['stock']) => (isNil(value?.quantity) ? value : value?.quantity),
+    },
+  },
+  { hasStock: { columnName: 'has_stock' } },
+  'slug',
+  'type',
+  'video',
+  'weight',
+  'gender',
+  { intGender: { columnName: 'int_gender' } },
+  { filters: { columnName: 'filters', type: HasuraGraphQLColumnType.Jsonb } },
+  { isKit: { columnName: 'is_kit' } },
+  { createdAt: { columnName: 'created_at' } },
+  { updatedAt: { columnName: 'updated_at' } },
+  { rate: { columnName: 'rating' } },
+  { reviewsTotal: { columnName: 'reviews_total' } },
+  { shoppingCount: { columnName: 'shopping_count' } },
+  { categoryId: { columnName: 'category_id' } },
+  {
+    category: {
+      columnName: 'category',
+      foreignKeyColumn: { id: 'categoryId' },
+      fields: ['id', 'name', 'reference', 'slug'],
+    },
+  },
+  'group',
+  { groupId: { columnName: 'group_id' } },
+  'validity',
+  { tagsCollection: { columnName: 'tags_collection', type: HasuraGraphQLColumnType.Jsonb } },
+  { tagsProfile: { columnName: 'tags_profile', type: HasuraGraphQLColumnType.Jsonb } },
+  { daysOfUse: { columnName: 'days_of_use' } },
+  { showVariants: { columnName: 'show_variants' } },
+  { variantSlug: { columnName: 'variant_slug' } },
+]
+
+export class ProductCatalogHasuraGraphQLRepository
+  extends withFindHasuraGraphQL(withHasuraGraphQL<ProductCatalogHasuraGraphQL>(Base))
+  implements ProductCatalogRepository
+{
+  constructor({
+    endpoint,
+    authOptions,
+    interceptors,
+    cache,
+  }: Pick<
+    HasuraConstructorParams<ProductCatalogHasuraGraphQL>,
+    'endpoint' | 'authOptions' | 'interceptors' | 'cache'
+  >) {
+    super({
+      tableName: 'product_catalog',
+      model: ProductCatalogHasuraGraphQL,
+      endpoint,
+      authOptions,
+      interceptors,
+      fields: commonFields,
+      cache,
+    })
+  }
+
+  async get({ id }: { id: string }, options?: { cache?: RepositoryCacheOptions }): Promise<Product> {
+    if (this.cache?.cacheAdapter && options?.cache?.enabled) {
+      const cacheKey = `${this.model.name.toLowerCase()}:id:${id}`
+      const cachedData = await this.cache.cacheAdapter.get<string>(cacheKey)
+
+      if (cachedData) {
+        this.logger.log(`Dados recuperados do cache: ${cacheKey}`)
+
+        return this.model.toInstance(deserialize(cachedData))
+      }
+    }
+
+    const product = await super
+      .find({
+        filters: {
+          id,
+        },
+        limits: {
+          limit: 1,
+        },
+      })
+      .then((res) => res.data.at(0))
+
+    if (!product) throw new NotFoundError(`Product not found`)
+
+    if (this.cache?.cacheAdapter && options?.cache?.enabled && product) {
+      const cacheKey = `${this.model.name.toLowerCase()}:id:${id}`
+
+      await this.cache.cacheAdapter.set({
+        key: cacheKey,
+        data: serialize(product),
+        expirationInSeconds: options?.cache?.ttl || this.cache.ttlDefault,
+      })
+
+      this.logger.log(`Dados salvos no cache: ${cacheKey}`)
+    }
+
+    return product
+  }
+
+  async getByEAN(EAN: string, options?: { cache?: RepositoryCacheOptions }): Promise<Product> {
+    if (this.cache?.cacheAdapter && options?.cache?.enabled) {
+      const cacheKey = `${this.model.name.toLowerCase()}:EAN:${EAN}`
+      const cachedData = await this.cache.cacheAdapter.get<string>(cacheKey)
+
+      if (cachedData) {
+        this.logger.log(`Dados recuperados do cache: ${cacheKey}`)
+
+        return this.model.toInstance(deserialize(cachedData))
+      }
+    }
+
+    const product = await super
+      .find({
+        filters: {
+          EAN,
+        },
+        limits: {
+          limit: 1,
+        },
+      })
+      .then((res) => res.data.at(0))
+
+    if (!product) return null
+
+    RoundProductPricesHelper.roundProductPrices(product)
+
+    if (this.cache?.cacheAdapter && options?.cache?.enabled && product) {
+      const cacheKey = `${this.model.name.toLowerCase()}:EAN:${EAN}`
+
+      await this.cache.cacheAdapter.set({
+        key: cacheKey,
+        data: serialize(product),
+        expirationInSeconds: options?.cache?.ttl || this.cache.ttlDefault,
+      })
+
+      this.logger.log(`Dados salvos no cache: ${cacheKey}`)
+    }
+
+    return product
+  }
+
+  override async find(
+    params?: FindRepositoryParams<ProductHasuraGraphQL>,
+    optionsParams?: { cache?: RepositoryCacheOptions },
+  ): Promise<RepositoryFindResult<ProductHasuraGraphQL>> {
+    const { filters, fields, ...options } = params || {}
+    const bindFields =
+      fields ||
+      (this.fields
+        .map((field) => (typeof field === 'string' ? field : Object.keys(field).shift()))
+        .filter((field) => field !== 'reviews' && field !== 'categories') as NonFunctionPropertyNames<
+        ProductHasuraGraphQL,
+        keyof ProductHasuraGraphQL
+      >[])
+
+    if (options.options?.minimal?.includes('price'))
+      options.options?.minimal.push('price.price', 'price.fullPrice', 'price.subscriberPrice')
+
+    if (options.options?.maximum?.includes('price'))
+      options.options?.maximum.push('price.price', 'price.fullPrice', 'price.subscriberPrice')
+
+    options.options?.minimal?.splice(options.options?.minimal.indexOf('price'), 1)
+    options.options?.maximum?.splice(options.options?.maximum.indexOf('price'), 1)
+
+    return super.find(
+      {
+        ...options,
+        filters: { ...filters },
+        fields: [
+          ...bindFields,
+          ...(bindFields.includes('price')
+            ? ([
+                'subscriberPrice',
+                'subscriberDiscountPercentage',
+                'fullPrice',
+              ] as NonFunctionPropertyNames<ProductHasuraGraphQL>[])
+            : []),
+        ],
+      },
+      optionsParams,
+    )
+  }
+
+  @Log()
+  async findCatalog(
+    params: FindRepositoryParams<ProductHasuraGraphQL>,
+    mainGender?: Extract<ProductGender, 'female' | 'male'>,
+    options?: { cache?: RepositoryCacheOptions },
+  ): Promise<RepositoryFindResult<ProductHasuraGraphQL>> {
+    const result = await this.find(
+      {
+        ...params,
+        filters: { ...params.filters, published: true },
+        orderBy: {
+          hasStock: 'desc',
+          ...(!mainGender ? {} : { intGender: mainGender === 'female' ? 'desc' : 'asc' }),
+          ...omit(params.orderBy, ['hasStock', 'intGender']),
+        },
+      },
+      options,
+    )
+
+    return result
+  }
+}

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
+  }
+}