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

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

@@ -0,0 +1,767 @@
+import {
+  CreateRepositoryParams,
+  FindRepositoryParams,
+  GetRepositoryParams,
+  NonFunctionPropertyNames,
+  PaginatedReviewFilters,
+  ProductGender,
+  ProductMetadata,
+  ProductRepository,
+  ProductReview,
+  ProductVariantReport,
+  RepositoryCacheOptions,
+  RepositoryFindResult,
+  ReviewStatusParams,
+  ReviewWithProductData,
+  RoundProductPricesHelper,
+  ShopPrice,
+  Shops,
+  UpdateRepositoryParams,
+  Where,
+} from '../../../../domain'
+import { NotFoundError } from '../../../../errors'
+import { Base, deserialize, is, isNil, Log, omit, serialize } from '../../../../utils'
+import { HasuraGraphQLColumnType } from '../../enums'
+import { HasuraConstructorParams, withCrudHasuraGraphQL, withHasuraGraphQL } from '../../mixins'
+import { ProductHasuraGraphQL } from '../../models'
+import { HasuraGraphQLFields } from '../../types'
+
+import {
+  ProductFetchReviewsHelper,
+  ProductReviewCacheHelper,
+  ProductReviewOperationsHelper,
+  ProductReviewUpdateHelper,
+  ProductVariantReportHelper,
+} from './helpers'
+
+const commonFields: HasuraGraphQLFields<ProductHasuraGraphQL> = [
+  { 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?.('","') || ''}"}` : '{}'),
+    },
+  },
+  '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' } },
+  { tags: { columnName: 'tags', type: HasuraGraphQLColumnType.Jsonb } },
+  { 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',
+  'validity',
+]
+
+const fieldsConfiguration: HasuraGraphQLFields<ProductHasuraGraphQL> = [
+  ...commonFields,
+  {
+    categories: {
+      columnName: 'categories',
+      fields: ['category_id'],
+      bindPersistData: (value: ProductHasuraGraphQL['categories']) => ({
+        categories: { data: value.map((category) => ({ category_id: +category })) },
+      }),
+      to: (categories: string[]) => categories.map((categoryId) => +categoryId),
+      from: (categories: { category_id: number }[]) =>
+        categories?.map((category) => category?.category_id?.toString()) || [],
+    },
+  },
+  {
+    kitProducts: {
+      columnName: 'kit_products',
+      foreignKeyColumn: { productId: 'id' },
+      fields: [
+        { productId: { columnName: 'product_id' } },
+        { kitProductId: { columnName: 'kit_product_id' } },
+        'quantity',
+        { product: { columnName: 'product', foreignKeyColumn: { id: 'product_id' }, fields: commonFields } },
+      ],
+    },
+  },
+  {
+    reviews: {
+      columnName: 'reviews',
+      foreignKeyColumn: { product_id: 'id' },
+      fields: [
+        'id',
+        'shop',
+        'rate',
+        'author',
+        'email',
+        'location',
+        'review',
+        'status',
+        'title',
+        { personId: { columnName: 'person_id' } },
+        'points',
+        { orderId: { columnName: 'order_id' } },
+        { createdAt: { columnName: 'created_at' } },
+        { updatedAt: { columnName: 'updated_at' } },
+      ],
+    },
+  },
+  {
+    metadata: {
+      columnName: 'metadata',
+      fields: ['title', 'description'],
+      bindPersistData: (value: ProductHasuraGraphQL['metadata']) => ({
+        metadata: { data: value },
+      }),
+    },
+  },
+]
+
+type ProductReviewFields = {
+  id?: string
+  shop: Shops
+  rate: number
+  author?: string
+  email?: string
+  location?: string
+  review?: string
+  status?: boolean
+  title?: string
+  person_id?: number
+  points?: number
+  order_id?: string
+  created_at?: Date
+  updated_at?: Date
+}
+
+type ReviewByAuthorParams = {
+  author: string
+  email: string
+  productId: number
+  orderId?: string
+}
+
+export class ProductHasuraGraphQLRepository
+  extends withCrudHasuraGraphQL(withHasuraGraphQL<ProductHasuraGraphQL>(Base))
+  implements ProductRepository
+{
+  private get reviewsFields(): any {
+    return [
+      'id',
+      'shop',
+      'rate',
+      'author',
+      'email',
+      'location',
+      'review',
+      'status',
+      'title',
+      { personId: { columnName: 'person_id' } },
+      'points',
+      { orderId: { columnName: 'order_id' } },
+      { createdAt: { columnName: 'created_at' } },
+      { updatedAt: { columnName: 'updated_at' } },
+    ]
+  }
+
+  constructor({
+    endpoint,
+    authOptions,
+    interceptors,
+    cache,
+  }: Pick<HasuraConstructorParams<ProductHasuraGraphQL>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>) {
+    super({
+      tableName: 'product',
+      model: ProductHasuraGraphQL,
+      endpoint,
+      authOptions,
+      interceptors,
+      fields: fieldsConfiguration,
+      cache,
+    })
+  }
+
+  override async create(params: CreateRepositoryParams<ProductHasuraGraphQL>): Promise<ProductHasuraGraphQL> {
+    const { metadata, ...data } = params
+    const product = await super.create(
+      omit({ ...data, metadata: metadata || { description: null, title: null } }, ['reviews']),
+    )
+
+    try {
+      product.reviews = data.reviews && (await this.updateReviews(+product.id, data))
+    } catch (error) {
+      await this.delete({ id: product.id })
+
+      throw error
+    }
+
+    return product
+  }
+
+  override async get(
+    identifiers: GetRepositoryParams<ProductHasuraGraphQL>,
+    options?: { cache?: RepositoryCacheOptions },
+  ): Promise<ProductHasuraGraphQL> {
+    const product = Number.isNaN(+identifiers.id)
+      ? (await this.find({ filters: { firestoreId: identifiers.id }, options: { enableCount: false } }, options))
+          .data?.[0]
+      : await super.get(identifiers, options)
+
+    if (product.productId) throw new NotFoundError('Product not found, it is a variant')
+
+    product.reviews = product.reviews || (await this.findReviewsByProduct(+product.id, options))
+
+    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, productId: { operator: Where.ISNULL } },
+        fields: [
+          ...bindFields,
+          ...(bindFields.includes('price')
+            ? ([
+                'subscriberPrice',
+                'subscriberDiscountPercentage',
+                'fullPrice',
+              ] as NonFunctionPropertyNames<ProductHasuraGraphQL>[])
+            : []),
+        ],
+      },
+      optionsParams,
+    )
+  }
+
+  @Log()
+  async getBySlug(slug: string, options?: { cache?: RepositoryCacheOptions }): Promise<ProductHasuraGraphQL> {
+    if (this.cache?.cacheAdapter && options?.cache?.enabled) {
+      const cacheKey = `${this.model.name.toLowerCase()}:slug:${slug}`
+      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 result = await this.find({
+      filters: {
+        slug,
+      },
+      fields: this.fields.map((field) =>
+        typeof field === 'string' ? field : Object.keys(field).shift(),
+      ) as NonFunctionPropertyNames<ProductHasuraGraphQL, keyof ProductHasuraGraphQL>[],
+      options: {
+        enableCount: false,
+      },
+    })
+
+    if (!result.data.length) return null
+
+    const product = result?.data?.shift()
+
+    RoundProductPricesHelper.roundProductPrices(product)
+
+    if (this.cache?.cacheAdapter && options?.cache?.enabled && product) {
+      const cacheKey = `${this.model.name.toLowerCase()}:slug:${slug}`
+
+      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 update(params: UpdateRepositoryParams<ProductHasuraGraphQL>): Promise<ProductHasuraGraphQL> {
+    const { kitProducts, reviews, id: checkId, metadata, ...data } = omit(params, ['categories', 'rate'])
+    const plainData = this.paramsToPlain({ id: checkId })
+    const id = await this.getId(plainData.id)
+    const product = await super.update({ id, ...data })
+
+    product.kitProducts = kitProducts && (await this.updateKitProducts(+id, { kitProducts }))
+    product.reviews = reviews && (await this.updateReviews(+id, { reviews }))
+    product.metadata = metadata && (await this.updateMetadata(+id, { metadata }))
+
+    return product
+  }
+
+  @Log()
+  async fetchProductReviews(
+    filters: PaginatedReviewFilters,
+    options?: { cache?: RepositoryCacheOptions },
+  ): Promise<ReviewWithProductData[]> {
+    const cacheKey = ProductReviewCacheHelper.generateProductReviewsCacheKey(filters, this.model.name)
+    const dependencies = {
+      cacheAdapter: this.cache?.cacheAdapter,
+      logger: this.logger,
+      modelName: this.model.name,
+      defaultTtl: this.cache?.ttlDefault,
+    }
+
+    if (ProductReviewCacheHelper.shouldUseCache(this.cache?.cacheAdapter, options)) {
+      const cachedData = await ProductReviewCacheHelper.tryGetFromCache({ key: cacheKey, dependencies })
+
+      if (cachedData) return cachedData as ReviewWithProductData[]
+    }
+
+    const limit = filters?.limit || 500
+    const data = await ProductReviewOperationsHelper.fetchAllProductsWithReviews({ repository: this, limit })
+    const reviews = ProductReviewOperationsHelper.processProductsToReviews({
+      data,
+      getReviewStatus: this.getReviewStatus.bind(this),
+    })
+    const filteredReviews = ProductReviewOperationsHelper.applyReviewFilters({ reviews, filters })
+
+    if (ProductReviewCacheHelper.shouldUseCache(this.cache?.cacheAdapter, options)) {
+      await ProductReviewCacheHelper.saveToCache({
+        key: cacheKey,
+        data: filteredReviews,
+        ttl: options?.cache?.ttl,
+        dependencies,
+      })
+    }
+
+    return filteredReviews
+  }
+
+  @Log()
+  async fetchReviews(
+    status: ReviewStatusParams,
+    options?: { cache?: RepositoryCacheOptions },
+  ): Promise<ReviewWithProductData[]> {
+    const cacheKey = ProductReviewCacheHelper.generateReviewsStatusCacheKey(status, this.model.name)
+    const dependencies = {
+      cacheAdapter: this.cache?.cacheAdapter,
+      logger: this.logger,
+      modelName: this.model.name,
+      defaultTtl: this.cache?.ttlDefault,
+    }
+
+    if (ProductReviewCacheHelper.shouldUseCache(this.cache?.cacheAdapter, options)) {
+      const cachedData = await ProductReviewCacheHelper.tryGetFromCache({ key: cacheKey, dependencies })
+
+      if (cachedData) return cachedData as ReviewWithProductData[]
+    }
+
+    const fetchDependencies = {
+      query: this.query.bind(this),
+      bindReviewToModel: this.bindReviewToModel,
+      reviewsFields: this.reviewsFields,
+    }
+
+    const reviews = await ProductFetchReviewsHelper.executeQuery(status, fetchDependencies)
+
+    if (ProductReviewCacheHelper.shouldUseCache(this.cache?.cacheAdapter, options)) {
+      await ProductReviewCacheHelper.saveToCache({
+        key: cacheKey,
+        data: reviews,
+        ttl: options?.cache?.ttl,
+        dependencies,
+      })
+    }
+
+    return reviews
+  }
+
+  @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
+  }
+
+  @Log()
+  async cleanShoppingCountFromIds(ids: string[]): Promise<void> {
+    return await this.mutation('update_product', ['affected_rows'], {
+      where: {
+        value: { id: { _nin: ids } },
+        type: 'product_bool_exp',
+        required: true,
+      },
+      _set: {
+        value: { shopping_count: 0 },
+        type: 'product_set_input',
+      },
+    })
+  }
+
+  private getReviewStatus(review: ProductReview): 'approved' | 'rejected' | 'pending' {
+    return review.status === true ? 'approved' : review.status === false ? 'rejected' : 'pending'
+  }
+
+  private async updateKitProducts(
+    productId: number,
+    { kitProducts }: Pick<UpdateRepositoryParams<ProductHasuraGraphQL>, 'kitProducts'>,
+  ): Promise<ProductHasuraGraphQL['kitProducts']> {
+    const plainData = this.paramsToPlain({ kitProducts })
+
+    await this.mutation('delete_product_kit', ['affected_rows'], {
+      where: {
+        type: 'product_kit_bool_exp',
+        required: true,
+        value: { kit_product_id: { _eq: productId } },
+      },
+    })
+
+    await this.mutation('insert_product_kit', ['affected_rows'], {
+      objects: {
+        type: '[product_kit_insert_input!]',
+        required: true,
+        value: plainData.kitProducts.map((kitProduct) => ({
+          kit_product_id: productId,
+          product_id: kitProduct.productId || kitProduct.product.id,
+          quantity: kitProduct.quantity,
+        })),
+      },
+    })
+
+    return plainData.kitProducts
+  }
+
+  private async updateReviews(
+    productId: number,
+    { reviews }: Pick<UpdateRepositoryParams<ProductHasuraGraphQL>, 'reviews'>,
+  ): Promise<ProductReview[]> {
+    const dependencies = {
+      mutation: this.mutation.bind(this),
+      findReview: this.findReview.bind(this),
+      bindReviewToModel: this.bindReviewToModel,
+      bindReviewToHasura: this.bindReviewToHasura,
+      reviewsFields: this.reviewsFields,
+      paramsToPlain: this.paramsToPlain.bind(this),
+    }
+
+    return ProductReviewUpdateHelper.executeUpdate(productId, reviews, dependencies)
+  }
+
+  private async updateMetadata(
+    productId: number,
+    { metadata }: Pick<UpdateRepositoryParams<ProductHasuraGraphQL>, 'metadata'>,
+  ): Promise<ProductMetadata> {
+    const plainData = this.paramsToPlain({ metadata })
+
+    if (!plainData.metadata) return null
+
+    await this.mutation('update_product_metadata_by_pk', ['product_id'], {
+      pk_columns: {
+        value: { product_id: productId },
+        type: 'product_metadata_pk_columns_input',
+        required: true,
+      },
+      _set: {
+        value: omit(metadata, ['product_id']),
+        type: 'product_metadata_set_input',
+        required: true,
+      },
+    })
+
+    return plainData.metadata
+  }
+
+  private async getId(id: string): Promise<string> {
+    if (!Number.isNaN(+id)) return id
+
+    const { data } = await this.find({ filters: { firestoreId: id }, options: { enableCount: false } })
+
+    if (data?.[0]?.id) return data?.[0]?.id
+
+    throw new NotFoundError(`Product with id ${id} not found`)
+  }
+
+  @Log()
+  private async findReviewsByProduct(
+    productId: number,
+    options?: { cache?: RepositoryCacheOptions },
+  ): Promise<ProductReview[]> {
+    if (this.cache?.cacheAdapter && options?.cache?.enabled) {
+      const cacheKey = `${this.model.name.toLowerCase()}:reviews:product:${productId}`
+      const cachedData = await this.cache.cacheAdapter.get<string>(cacheKey)
+
+      if (cachedData) {
+        this.logger.log(`Dados recuperados do cache: ${cacheKey}`)
+
+        return deserialize(cachedData).map((review: any) => new ProductReview(review))
+      }
+    }
+
+    const { product_review: data } = await this.query('product_review', this.reviewsFields, {
+      where: {
+        value: {
+          product_id: { _eq: productId },
+        },
+        type: 'product_review_bool_exp',
+        required: true,
+      },
+    })
+
+    const reviews = data?.map((review: Record<string, any>) => this.bindReviewToModel(review))
+
+    if (this.cache?.cacheAdapter && options?.cache?.enabled && reviews) {
+      const cacheKey = `${this.model.name.toLowerCase()}:reviews:product:${productId}`
+
+      await this.cache.cacheAdapter.set({
+        key: cacheKey,
+        data: serialize(reviews),
+        expirationInSeconds: options?.cache?.ttl || this.cache.ttlDefault,
+      })
+
+      this.logger.log(`Dados salvos no cache: ${cacheKey}`)
+    }
+
+    return reviews
+  }
+
+  private async findReview(review: ProductReview, productId: number): Promise<ProductReview> {
+    if (review.id) return review
+
+    let loadedReview: ProductReview
+
+    if (review.personId) loadedReview = await this.getReviewByPersonId(review.personId, productId, review.orderId)
+
+    if (!loadedReview && review.author && review.email)
+      loadedReview = await this.getReviewByAuthorAndEmail({
+        author: review.author,
+        email: review.email,
+        productId,
+        orderId: review.orderId,
+      })
+
+    return loadedReview || review
+  }
+
+  private async getReviewByPersonId(personId: number, productId: number, orderId?: string): Promise<ProductReview> {
+    const { product_review: data } = await this.query('product_review', this.reviewsFields, {
+      where: {
+        value: {
+          product_id: { _eq: productId },
+          person_id: { _eq: personId },
+          ...(orderId && { order_id: { _eq: orderId } }),
+        },
+        type: 'product_review_bool_exp',
+        required: true,
+      },
+    })
+
+    return data?.[0] && this.bindReviewToModel(data[0])
+  }
+
+  private async getReviewByAuthorAndEmail(params: ReviewByAuthorParams): Promise<ProductReview> {
+    const { author, email, productId, orderId } = params
+
+    const { product_review: data } = await this.query('product_review', this.reviewsFields, {
+      where: {
+        value: {
+          product_id: { _eq: productId },
+          author: { _eq: author },
+          email: { _eq: email },
+          ...(orderId && { order_id: { _eq: orderId } }),
+        },
+        type: 'product_review_bool_exp',
+        required: true,
+      },
+    })
+
+    return data?.[0] && this.bindReviewToModel(data[0])
+  }
+
+  private bindReviewToModel = (
+    plain: Record<'person_id' | 'order_id' | 'created_at' | 'updated_at', any>,
+  ): ProductReview =>
+    ProductReview.toInstance({
+      ...is<ProductReview>(omit(plain, ['product_id', 'created_at', 'updated_at', 'person_id', 'order_id'])),
+      createdAt: typeof plain.created_at === 'string' ? new Date(plain.created_at) : plain.created_at,
+      updatedAt: typeof plain.updated_at === 'string' ? new Date(plain.updated_at) : plain.updated_at,
+      personId: plain.person_id,
+      orderId: plain.order_id,
+    })
+
+  private bindReviewToHasura = (review: ProductReview): ProductReviewFields => ({
+    ...is<ProductReviewFields>(omit(review, ['productId', 'createdAt', 'updatedAt', 'personId', 'orderId'])),
+    person_id: review.personId,
+    order_id: review.orderId,
+  })
+
+  async productVariantFullReport(): Promise<ProductVariantReport[]> {
+    const dependencies = {
+      query: this.query.bind(this),
+    }
+
+    return ProductVariantReportHelper.executeReport(dependencies)
+  }
+}