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

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

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