@infrab4a/connect 5.7.2 → 5.7.3

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

@@ -0,0 +1,55 @@
+import { ProductPriceLog, ProductPriceLogRepository } from '../../../../domain'
+import { Base } from '../../../../utils'
+import { HasuraGraphQLColumnType } from '../../enums'
+import { HasuraConstructorParams, withCrudHasuraGraphQL, withHasuraGraphQL } from '../../mixins'
+
+export class ProductPriceLogHasuraGraphQLRepository
+  extends withCrudHasuraGraphQL(withHasuraGraphQL<ProductPriceLog>(Base))
+  implements ProductPriceLogRepository
+{
+  constructor({
+    endpoint,
+    authOptions,
+    interceptors,
+    cache,
+  }: Pick<HasuraConstructorParams<ProductPriceLog>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>) {
+    super({
+      tableName: 'product_price_log',
+      model: ProductPriceLog,
+      endpoint,
+      authOptions,
+      interceptors,
+      fields: [
+        {
+          id: {
+            columnName: 'id',
+            to: (value: string) => +value,
+            from: (value: number) => value.toString(),
+          },
+        },
+        { productId: { columnName: 'product_id' } },
+        { productEAN: { columnName: 'product_ean' } },
+        { productSKU: { columnName: 'product_sku' } },
+        { productName: { columnName: 'product_name' } },
+        { productCostPrice: { columnName: 'product_cost_price' } },
+        { productPrice: { columnName: 'product_price' } },
+        { productSubscriberPrice: { columnName: 'product_subscriber_price' } },
+        { productSubscriberDiscountPercentage: { columnName: 'product_subscriber_discount_percentage' } },
+        { markupMin: { columnName: 'markup_min' } },
+        { markupWithoutCompetitor: { columnName: 'markup_without_competitor' } },
+        { discountCompetitor: { columnName: 'discount_competitor' } },
+        { minViablePrice: { columnName: 'min_viable_price' } },
+        { targetPrice: { columnName: 'target_price' } },
+        { groupId: { columnName: 'group_id' } },
+        { competitorsAndPrices: { columnName: 'competitors_and_prices', type: HasuraGraphQLColumnType.Jsonb } },
+        { competitorsPrices: { columnName: 'competitors_prices', type: HasuraGraphQLColumnType.Jsonb } },
+        { competitorsMinPrice: { columnName: 'competitors_min_price' } },
+        { competitorsSellerMinPrice: { columnName: 'competitors_seller_min_price' } },
+        { statusPrecificacao: { columnName: 'status_precificacao' } },
+        { createdAt: { columnName: 'created_at' } },
+        { updatedAt: { columnName: 'updated_at' } },
+      ],
+      cache,
+    })
+  }
+}

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

@@ -0,0 +1,96 @@
+import { ProductReview } from '../../../../domain'
+import { ProductReviewRepository } from '../../../../domain/catalog/repositories'
+import { Base, Log } from '../../../../utils'
+import { HasuraConstructorParams, withCrudHasuraGraphQL, withHasuraGraphQL } from '../../mixins'
+
+export class ProductReviewHasuraGraphQLRepository
+  extends withCrudHasuraGraphQL(withHasuraGraphQL<ProductReview>(Base))
+  implements ProductReviewRepository
+{
+  constructor({
+    endpoint,
+    authOptions,
+    interceptors,
+    cache,
+  }: Pick<HasuraConstructorParams<ProductReview>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>) {
+    super({
+      tableName: 'product_review',
+      model: ProductReview,
+      endpoint,
+      authOptions,
+      interceptors,
+      fields: [
+        'id',
+        { productId: { columnName: 'product_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' } },
+        {
+          product: {
+            columnName: 'product',
+            foreignKeyColumn: { id: 'productId' },
+            fields: [
+              'id',
+              {
+                productId: {
+                  columnName: 'main_product_id',
+                  to: (value: string) => +value,
+                  from: (value: number) => value?.toString(),
+                },
+              },
+              'ean',
+              'sku',
+              'name',
+              'brand',
+              'slug',
+              'images',
+              'grade',
+              'gender',
+              '',
+            ],
+          },
+        },
+      ],
+      cache,
+    })
+  }
+
+  async updateManyStatus(reviews: Pick<ProductReview, 'id' | 'status'>[]): Promise<void> {
+    return await this.mutation('update_product_review_many', ['affected_rows'], {
+      updates: {
+        type: '[product_review_updates!]',
+        required: true,
+        value: [
+          {
+            _set: { status: true },
+            where: { id: { _in: reviews.filter((review) => review.status).map((review) => review.id) } },
+          },
+          {
+            _set: { status: false },
+            where: { id: { _in: reviews.filter((review) => !review.status).map((review) => review.id) } },
+          },
+        ],
+      },
+    })
+  }
+
+  @Log()
+  aproveReview(id: number) {
+    return this.update({ id, status: true })
+  }
+
+  @Log()
+  disaproveReview(id: number) {
+    return this.update({ id, status: false })
+  }
+}

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

@@ -0,0 +1,39 @@
+import { ProductStockEntry } from '../../../../domain'
+import { ProductStockEntryRepository } from '../../../../domain/catalog/repositories'
+import { Base } from '../../../../utils'
+import { HasuraConstructorParams, withCrudHasuraGraphQL, withHasuraGraphQL } from '../../mixins'
+
+export class ProductStockEntryHasuraGraphQLRepository
+  extends withCrudHasuraGraphQL(withHasuraGraphQL<ProductStockEntry>(Base))
+  implements ProductStockEntryRepository
+{
+  constructor({
+    endpoint,
+    authOptions,
+    interceptors,
+    cache,
+  }: Pick<HasuraConstructorParams<ProductStockEntry>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>) {
+    super({
+      tableName: 'product_millenium_stock_entry',
+      model: ProductStockEntry,
+      endpoint,
+      authOptions,
+      interceptors,
+      cache,
+      fields: [
+        'id',
+        { productId: { columnName: 'product_id' } },
+        { codProduct: { columnName: 'cod_product' } },
+        { productDescription: { columnName: 'product_description' } },
+        { eventDescription: { columnName: 'event_description' } },
+        { invoiceValue: { columnName: 'invoice_value' } },
+        'price',
+        'quantity',
+        { invoiceId: { columnName: 'invoice_id' } },
+        { nfeKey: { columnName: 'nfe_key' } },
+        'batch',
+        { createdAt: { columnName: 'created_at' } },
+      ],
+    })
+  }
+}

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

@@ -0,0 +1,116 @@
+import {
+  Filter,
+  ProductStockNotification,
+  ReportStockNotification,
+  ReportStockNotificationInput,
+  RepositoryFindResult,
+  Shops,
+} from '../../../../domain'
+import { ProductStockNotificationRepository } from '../../../../domain/catalog/repositories'
+import { Base } from '../../../../utils'
+import { HasuraConstructorParams, withCrudHasuraGraphQL, withHasuraGraphQL } from '../../mixins'
+
+type AddCustomerEmailParams = {
+  shop: Shops
+  productId: string
+  name: string
+  email: string
+}
+
+export class ProductStockNotificationHasuraGraphQLRepository
+  extends withCrudHasuraGraphQL(withHasuraGraphQL<ProductStockNotification>(Base))
+  implements ProductStockNotificationRepository
+{
+  constructor({
+    endpoint,
+    authOptions,
+    interceptors,
+    cache,
+  }: Pick<HasuraConstructorParams<Filter>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>) {
+    super({
+      tableName: 'product_stock_notification',
+      model: ProductStockNotification,
+      endpoint,
+      authOptions,
+      interceptors,
+      cache,
+      fields: [
+        'id',
+        { productId: { columnName: 'product_id' } },
+        'name',
+        'email',
+        'shop',
+        { createdAt: { columnName: 'created_at' } },
+        { updatedAt: { columnName: 'updated_at' } },
+      ],
+    })
+  }
+
+  async addCustomerEmail(params: AddCustomerEmailParams): Promise<void> {
+    const { shop, productId, name, email } = params
+
+    const notification = await this.find({
+      filters: {
+        productId,
+        email,
+      },
+    }).then((data) => data.data.shift())
+
+    if (!notification)
+      this.create({
+        shop,
+        productId,
+        name,
+        email,
+      })
+  }
+
+  public async getNotificationsReport(
+    params: ReportStockNotificationInput,
+    orderBy: { field: string; direction: string },
+    pagination?: { offset: number; limit: number },
+  ): Promise<RepositoryFindResult<ReportStockNotification>> {
+    const query = {
+      ...(params.productId && { product_id: { _eq: params.productId } }),
+      ...(params.ean && { ean: { _eq: params.ean } }),
+      ...(params.sku && { sku: { _eq: params.sku } }),
+      ...(params.name && { name: { _iregex: params.name } }),
+      ...(params.categoryId && { category_id: { _eq: params.categoryId } }),
+      ...(params.category && { category: { _iregex: params.category } }),
+      ...(params.reference && { category_reference: { _eq: params.reference } }),
+      ...(params.emailsCount && { emails_registered: { _eq: params.emailsCount } }),
+    }
+
+    const orderByField = {
+      [orderBy.field]: orderBy.direction,
+    }
+
+    const {
+      report_stock_notification: reportStockNotification,
+    }: { report_stock_notification: ReportStockNotification[] } = await this.query(
+      'report_stock_notification',
+      ['product_id', 'ean', 'sku', 'name', 'stock', 'category_id', 'category', 'reference', 'emails_registered'],
+      {
+        where: {
+          type: 'report_stock_notification_bool_exp',
+          value: query,
+          required: true,
+        },
+        order_by: {
+          type: '[report_stock_notification_order_by]',
+          value: orderByField,
+          required: true,
+        },
+      },
+    )
+
+    const data = pagination?.limit
+      ? reportStockNotification.slice(pagination?.offset, pagination?.offset + pagination?.limit)
+      : reportStockNotification
+
+    return {
+      data,
+      count: reportStockNotification.length,
+    }
+  }
+}

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

@@ -0,0 +1,374 @@
+import {
+  FindRepositoryParams,
+  GetRepositoryParams,
+  ProductMetadata,
+  RepositoryFindResult,
+  ShopPrice,
+  UpdateRepositoryParams,
+  VariantRepository,
+  Where,
+} from '../../../../domain'
+import { NotFoundError } from '../../../../errors'
+import { Base, isNil, omit } from '../../../../utils'
+import { HasuraGraphQLColumnType } from '../../enums'
+import { HasuraConstructorParams, withCrudHasuraGraphQL, withHasuraGraphQL } from '../../mixins'
+import { ProductHasuraGraphQL, VariantHasuraGraphQL } from '../../models'
+import { HasuraGraphQLFields } from '../../types'
+
+const fieldsConfiguration: HasuraGraphQLFields<VariantHasuraGraphQL> = [
+  { id: { columnName: 'id', to: (value: string) => +value, from: (value: number) => value.toString() } },
+  { firestoreId: { columnName: 'firestore_id' } },
+  {
+    productId: {
+      columnName: 'main_product_id',
+      to: (value: string) => +value,
+      from: (value: number) => value?.toString(),
+    },
+  },
+  { EAN: { columnName: 'ean' } },
+  { costPrice: { columnName: 'cost_price' } },
+  {
+    price: {
+      columnName: 'price',
+      from: (
+        price: number,
+        data: Record<
+          | 'price'
+          | 'full_price'
+          | 'subscriber_discount_percentage'
+          | 'subscriber_price'
+          | 'full_price_discount_percentage',
+          any
+        >,
+      ): ShopPrice => ({
+        price,
+        fullPrice: data.full_price,
+        subscriberDiscountPercentage: data.subscriber_discount_percentage,
+        subscriberPrice: data.subscriber_price,
+        fullPriceDiscountPercentage: data.full_price_discount_percentage,
+      }),
+      bindFindFilter: (sentence) => {
+        const filters = Object.values(sentence).shift()
+
+        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: VariantHasuraGraphQL['price']) => ({
+        ...((priceData?.price || 0) >= 0 && { price: priceData.price }),
+        ...((priceData?.fullPrice || 0) >= 0 && { full_price: priceData.fullPrice }),
+        ...((priceData?.subscriberDiscountPercentage || 0) >= 0 && {
+          subscriber_discount_percentage: priceData.subscriberDiscountPercentage,
+        }),
+        ...((priceData?.subscriberPrice || 0) >= 0 && { subscriber_price: priceData.subscriberPrice }),
+        ...(priceData.fullPriceDiscountPercentage >= 0 && {
+          full_price_discount_percentage: priceData.fullPriceDiscountPercentage,
+        }),
+      }),
+    },
+  },
+  { fullPrice: { columnName: 'full_price' } },
+  { subscriberDiscountPercentage: { columnName: 'subscriber_discount_percentage' } },
+  { subscriberPrice: { columnName: 'subscriber_price' } },
+  { fullPriceDiscountPercentage: { columnName: 'full_price_discount_percentage' } },
+  'sku',
+  {
+    stock: {
+      columnName: 'stock',
+      from: (quantity: number) => ({ quantity }),
+      to: (value: VariantHasuraGraphQL['stock']) => (isNil(value?.quantity) ? value : value?.quantity),
+    },
+  },
+  { hasStock: { columnName: 'has_stock' } },
+  'weight',
+  { name: { to: () => '', from: (): undefined => undefined } },
+  { hasVariants: { columnName: 'has_variants', to: () => false, from: (): undefined => undefined } },
+  { createdAt: { columnName: 'created_at' } },
+  { updatedAt: { columnName: 'updated_at' } },
+  {
+    grade: {
+      columnName: 'grade',
+      type: HasuraGraphQLColumnType.Jsonb,
+    },
+  },
+  'group',
+  { groupId: { columnName: 'group_id' } },
+  'type',
+  'validity',
+  'published',
+  { tagsCollection: { columnName: 'tags_collection', type: HasuraGraphQLColumnType.Jsonb } },
+  { tagsProfile: { columnName: 'tags_profile', type: HasuraGraphQLColumnType.Jsonb } },
+  { tagsSupply: { columnName: 'tags_supply', type: HasuraGraphQLColumnType.Jsonb } },
+  { daysOfUse: { columnName: 'days_of_use' } },
+  {
+    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?.('","') || ''}"}` : '{}'),
+    },
+  },
+  'slug',
+  'brand',
+  'name',
+  'sku',
+  { NCM: { columnName: 'ncm' } },
+  { CEST: { columnName: 'cest' } },
+  {
+    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' } },
+  'gender',
+  { intGender: { columnName: 'int_gender' } },
+  'label',
+  { filters: { columnName: 'filters', type: HasuraGraphQLColumnType.Jsonb } },
+  { 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'],
+    },
+  },
+  {
+    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()) || [],
+    },
+  },
+  {
+    metadata: {
+      columnName: 'metadata',
+      fields: ['title', 'description'],
+      bindPersistData: (value: ProductHasuraGraphQL['metadata']) => ({
+        metadata: { data: value },
+      }),
+    },
+  },
+  {
+    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' } },
+      ],
+    },
+  },
+  { variantSlug: { columnName: 'variant_slug' } },
+  { caixariaMinima: { columnName: 'caixaria_minima', type: HasuraGraphQLColumnType.Jsonb } },
+  'suppliers',
+  'curve',
+  { createdAt: { columnName: 'created_at' } },
+  { updatedAt: { columnName: 'updated_at' } },
+]
+
+export class VariantHasuraGraphQLRepository
+  extends withCrudHasuraGraphQL(withHasuraGraphQL<VariantHasuraGraphQL>(Base))
+  implements VariantRepository
+{
+  constructor({
+    endpoint,
+    authOptions,
+    interceptors,
+    cache,
+  }: Pick<HasuraConstructorParams<VariantHasuraGraphQL>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>) {
+    super({
+      tableName: 'product',
+      model: VariantHasuraGraphQL,
+      endpoint,
+      authOptions,
+      interceptors,
+      cache,
+      fields: fieldsConfiguration,
+    })
+  }
+
+  override async get(identifiers: GetRepositoryParams<VariantHasuraGraphQL>): Promise<VariantHasuraGraphQL> {
+    if (!identifiers.id) {
+      throw new NotFoundError('Variant ID is required')
+    }
+
+    const variant = Number.isNaN(+identifiers.id)
+      ? (await this.find({ filters: { firestoreId: identifiers.id } })).data?.[0]
+      : await super.get(identifiers)
+
+    if (!variant.productId) throw new NotFoundError('Variant not found, it is a product')
+
+    return variant
+  }
+
+  override async find(
+    params?: FindRepositoryParams<VariantHasuraGraphQL>,
+  ): Promise<RepositoryFindResult<VariantHasuraGraphQL>> {
+    const { filters, ...options } = params || {}
+
+    return super.find({ ...options, filters: { productId: { operator: Where.ISNOTNULL }, ...filters } })
+  }
+
+  async getByEAN(EAN: string): Promise<VariantHasuraGraphQL> {
+    const { data } = await this.find({
+      filters: {
+        EAN,
+      },
+      options: {
+        enableCount: false,
+      },
+    })
+
+    return data.at(0)
+  }
+
+  override async update(params: UpdateRepositoryParams<VariantHasuraGraphQL>): Promise<VariantHasuraGraphQL> {
+    const { productId, id: checkId, metadata, ...data } = params
+    const dataWithProductId = this.paramsToPlain({ id: checkId, productId })
+
+    if (!dataWithProductId.id) {
+      throw new NotFoundError('Variant ID is required for update')
+    }
+
+    const id = await this.getId(dataWithProductId.id)
+    const product = await super.update({ id, ...data })
+
+    product.metadata = metadata && (await this.updateMetadata(+id, { metadata }))
+
+    if (dataWithProductId.productId) {
+      product.productId = dataWithProductId.productId
+    }
+
+    return product
+  }
+
+  private async updateMetadata(
+    productId: number,
+    { metadata }: Pick<UpdateRepositoryParams<ProductHasuraGraphQL>, 'metadata'>,
+  ): Promise<ProductMetadata> {
+    const plainData = this.paramsToPlain({ metadata })
+
+    if (!plainData.metadata) return null
+
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    const { update_product_metadata_by_pk } = 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,
+      },
+    })
+
+    if (!update_product_metadata_by_pk) {
+      await this.mutation('insert_product_metadata', ['affected_rows'], {
+        objects: {
+          type: '[product_metadata_insert_input!]!',
+          value: [{ product_id: productId, ...metadata }],
+        },
+      })
+    }
+
+    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`)
+  }
+}