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

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

@@ -1,71 +0,0 @@
-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' } },
-      ],
-      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-notification-hasura-graphql.repository.ts

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

@@ -1,179 +0,0 @@
-import {
-  FindRepositoryParams,
-  GetRepositoryParams,
-  RepositoryFindResult,
-  ShopPrice,
-  UpdateRepositoryParams,
-  VariantRepository,
-  Where,
-} from '../../../../domain'
-import { NotFoundError } from '../../../../errors'
-import { Base, isNil } from '../../../../utils'
-import { HasuraGraphQLColumnType } from '../../enums'
-import { HasuraConstructorParams, withCrudHasuraGraphQL, withHasuraGraphQL } from '../../mixins'
-import { 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',
-  'validity',
-  { tags: { columnName: 'tags', type: HasuraGraphQLColumnType.Jsonb } },
-  'published',
-]
-
-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 } })
-  }
-
-  override async update(params: UpdateRepositoryParams<VariantHasuraGraphQL>): Promise<VariantHasuraGraphQL> {
-    const { productId, id: checkId, ...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 })
-
-    if (dataWithProductId.productId) {
-      product.productId = dataWithProductId.productId
-    }
-
-    return product
-  }
-
-  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`)
-  }
-}