@infrab4a/connect-angular 6.0.0-alpha.0 → 6.0.0-beta.0

package/src/services/checkout/checkout-repositories.facade.ts

@@ -1,10 +0,0 @@
-import { Inject, Injectable } from '@angular/core'
-import { CheckoutRepository, UserRepository } from '@infrab4a/connect'
-
-@Injectable()
-export class CheckoutRepositoriesFacade {
-  constructor(
-    @Inject('CheckoutRepository') public readonly checkoutRepository: CheckoutRepository,
-    @Inject('UserRepository') public readonly userRepository: UserRepository,
-  ) {}
-}

package/src/services/checkout-subscription.service.ts

@@ -1,76 +0,0 @@
-import { Inject, Injectable } from '@angular/core'
-import {
-  CheckoutSubscription,
-  CheckoutSubscriptionRepository,
-  CheckoutTypes,
-  Coupon,
-  isNil,
-  pick,
-} from '@infrab4a/connect'
-import { Observable } from 'rxjs'
-import { concatMap } from 'rxjs/operators'
-
-
-import { PERSISTENCE_PROVIDER } from '../consts'
-import { DataPersistence } from '../persistence'
-
-import { RequiredCheckoutSubscriptionData } from './types'
-import { CouponService } from './coupon.service'
-
-@Injectable()
-export class CheckoutSubscriptionService {
-  constructor(
-    @Inject('CheckoutSubscriptionRepository')
-    private readonly checkoutSubscriptionRepository: CheckoutSubscriptionRepository,
-    @Inject(PERSISTENCE_PROVIDER) private readonly dataPersistence: DataPersistence,
-    private readonly couponService: CouponService,
-  ) {}
-
-  getCheckoutSubscription(checkoutData?: RequiredCheckoutSubscriptionData): Observable<CheckoutSubscription> {
-    return this.dataPersistence
-      .get('checkoutSubscriptionId')
-      .pipe(
-        concatMap((id) =>
-          !isNil(id) ? this.checkoutSubscriptionRepository.get({ id }) : this.createCheckoutSubscription(checkoutData),
-        ),
-      )
-  }
-
-  clearCheckoutSubscriptionFromSession(): Observable<void> {
-    return this.dataPersistence.remove('checkoutSubscriptionId')
-  }
-
-  checkCoupon(nickname: string, _userEmail: string): Observable<Coupon> {
-    return this.getCheckoutSubscription().pipe(
-      concatMap((checkout) =>
-        this.couponService
-          .checkCoupon({
-            nickname,
-            checkoutType: CheckoutTypes.SUBSCRIPTION,
-            checkout,
-            plan: checkout.subscriptionPlan.name,
-          })
-          .pipe(),
-      ),
-    )
-  }
-
-  calcDiscountSubscription(coupon: Coupon) {
-    return this.getCheckoutSubscription().pipe(
-      concatMap((checkout) => this.couponService.calcDiscountSubscription(coupon, checkout).pipe()),
-    )
-  }
-
-  private async createCheckoutSubscription(
-    checkoutData?: RequiredCheckoutSubscriptionData,
-  ): Promise<CheckoutSubscription> {
-    const checkout = await this.checkoutSubscriptionRepository.create({
-      createdAt: new Date(),
-      ...CheckoutSubscription.toInstance(pick(checkoutData, ['user', 'shop'])).toPlain(),
-    })
-
-    await this.dataPersistence.set('checkoutSubscriptionId', checkout.id).toPromise()
-
-    return checkout
-  }
-}

package/src/services/checkout.service.ts

@@ -1,196 +0,0 @@
-import {
-  Checkout,
-  CheckoutPayloadRequest,
-  CheckoutResponse,
-  CheckoutStockValidation,
-  CheckoutTypes,
-  Coupon,
-  isNil,
-  NotFoundError,
-  pick,
-  ShippingMethodResponse,
-  ShippingProductRequest,
-  User,
-  UserAddress,
-} from '@infrab4a/connect'
-import { from, Observable, of, throwError } from 'rxjs'
-import { concatMap, map } from 'rxjs/operators'
-import { Injectable } from '@angular/core'
-
-import { RequiredCheckoutData } from './types'
-import { CheckoutDependenciesFacade, CheckoutRepositoriesFacade } from './checkout'
-import { ConfigurationFacade } from './shared'
-
-@Injectable()
-export class CheckoutService {
-  private checkoutUrl: string = null
-
-  constructor(
-    private readonly repositoriesFacade: CheckoutRepositoriesFacade,
-    private readonly dependenciesFacade: CheckoutDependenciesFacade,
-    private readonly configurationFacade: ConfigurationFacade,
-  ) {
-    this.checkoutUrl = this.configurationFacade.getCheckoutUrl()
-  }
-
-  getCheckout(checkoutData?: RequiredCheckoutData): Observable<Checkout> {
-    return this.dependenciesFacade.dataPersistence
-      .get('checkoutId')
-      .pipe(
-        concatMap((id) =>
-          !isNil(id) ? this.repositoriesFacade.checkoutRepository.get({ id }) : this.createCheckout(checkoutData),
-        ),
-      )
-  }
-
-  getUserByCheckout(checkoutId: string): Observable<User> {
-    return from(this.repositoriesFacade.checkoutRepository.get({ id: checkoutId })).pipe(
-      concatMap((checkout) =>
-        checkout?.user?.id
-          ? of(checkout.user)
-          : from(this.repositoriesFacade.userRepository.get({ id: checkout.user.id })),
-      ),
-      concatMap((user) => of(user) || throwError(() => new NotFoundError('User is not found'))),
-    )
-  }
-
-  updateCheckoutLineItems(checkout: Partial<Checkout>): Observable<Checkout> {
-    return from(
-      this.repositoriesFacade.checkoutRepository.update(
-        Checkout.toInstance({ id: checkout.id, lineItems: checkout.lineItems }),
-      ),
-    )
-  }
-
-  updateCheckoutUser(checkout: Partial<Checkout>): Observable<Checkout> {
-    return from(
-      this.repositoriesFacade.checkoutRepository.update(Checkout.toInstance({ id: checkout.id, user: checkout.user })),
-    )
-  }
-
-  clearCheckoutFromSession(): Observable<void> {
-    return this.dependenciesFacade.dataPersistence.remove('checkoutId')
-  }
-
-  resetCheckoutValues(): Observable<Checkout> {
-    return this.getCheckout().pipe(
-      concatMap((checkout) =>
-        this.dependenciesFacade.httpClient.post(`${this.checkoutUrl}/checkoutResetValues`, {
-          checkoutId: checkout.id,
-        }),
-      ),
-      concatMap(() => this.getCheckout()),
-    )
-  }
-
-  applyCouponDiscount(nickname: string, checkoutType: CheckoutTypes): Observable<Coupon> {
-    return this.getCheckout().pipe(
-      concatMap((checkout) =>
-        this.dependenciesFacade.httpClient.post(`${this.checkoutUrl}/checkoutApplyDiscount`, {
-          checkoutId: checkout.id,
-          coupon: nickname,
-          checkoutType,
-        }),
-      ),
-      concatMap(() => this.getCheckout()),
-      map((checkout) => checkout.coupon),
-    )
-  }
-
-  removeCouponDiscount(): Observable<Checkout> {
-    return this.getCheckout().pipe(
-      concatMap((checkout) =>
-        this.dependenciesFacade.httpClient.post(`${this.checkoutUrl}/checkoutRemoveDiscount`, {
-          checkoutId: checkout.id,
-        }),
-      ),
-      concatMap(() => this.getCheckout()),
-    )
-  }
-
-  validateStockProducts(): Observable<CheckoutStockValidation> {
-    return this.getCheckout().pipe(
-      concatMap((checkout) =>
-        this.dependenciesFacade.httpClient.post<{
-          valid: boolean
-          outOfStock: string[]
-          limitedStock: string[]
-        }>(`${this.checkoutUrl}/checkoutValidateProductStock`, {
-          checkoutId: checkout.id,
-        }),
-      ),
-    )
-  }
-
-  selectShippingAddress(address: UserAddress): Observable<Checkout> {
-    return this.getCheckout().pipe(
-      concatMap((checkout) => {
-        return this.repositoriesFacade.checkoutRepository.update(
-          Checkout.toInstance({ id: checkout.id, shippingAddress: address, billingAddress: address }),
-        )
-      }),
-    )
-  }
-
-  getAvailableShippingForProduct(productShipping: ShippingProductRequest): Observable<ShippingMethodResponse[]> {
-    return this.dependenciesFacade.httpClient.post<ShippingMethodResponse[]>(
-      `${this.checkoutUrl}/checkoutGetAvailableShipping`,
-      {
-        checkoutId: null,
-        productShipping,
-      },
-    )
-  }
-
-  getAvailableShippingForCheckout(): Observable<ShippingMethodResponse[]> {
-    return this.getCheckout().pipe(
-      concatMap((checkout) =>
-        this.dependenciesFacade.httpClient.post<ShippingMethodResponse[]>(
-          `${this.checkoutUrl}/checkoutGetAvailableShipping`,
-          {
-            checkoutId: checkout.id,
-            productShipping: null,
-          },
-        ),
-      ),
-    )
-  }
-
-  selectShipping(option: string): Observable<Checkout> {
-    return this.getCheckout().pipe(
-      concatMap((checkout) =>
-        this.dependenciesFacade.httpClient.post(`${this.checkoutUrl}/checkoutSelectShipping`, {
-          checkoutId: checkout.id,
-          shippingOption: option,
-        }),
-      ),
-      concatMap(() => this.getCheckout()),
-    )
-  }
-
-  createOrder(
-    checkoutPayload: CheckoutPayloadRequest,
-    paymentProvider: string,
-    applicationVersion: string,
-  ): Observable<CheckoutResponse> {
-    return this.dependenciesFacade.httpClient.post<CheckoutResponse>(`${this.checkoutUrl}/checkout`, {
-      data: {
-        ...checkoutPayload,
-        applicationVersion,
-        paymentProvider,
-      },
-    })
-  }
-
-  private async createCheckout(checkoutData?: RequiredCheckoutData): Promise<Checkout> {
-    const checkout = await this.repositoriesFacade.checkoutRepository.create({
-      createdAt: new Date(),
-      ...Checkout.toInstance(pick(checkoutData, ['user', 'shop'])).toPlain(),
-      shop: checkoutData?.shop || this.configurationFacade.defaultShop,
-    })
-
-    await this.dependenciesFacade.dataPersistence.set('checkoutId', checkout.id).toPromise()
-
-    return checkout
-  }
-}

package/src/services/coupon/coupon-repositories.facade.ts

@@ -1,11 +0,0 @@
-import { Inject, Injectable } from '@angular/core'
-import { CategoryRepository, CouponRepository, OrderRepository } from '@infrab4a/connect'
-
-@Injectable()
-export class CouponRepositoriesFacade {
-  constructor(
-    @Inject('CouponRepository') public readonly couponRepository: CouponRepository,
-    @Inject('OrderRepository') public readonly orderRepository: OrderRepository,
-    @Inject('CategoryRepository') public readonly categoryRepository: CategoryRepository,
-  ) {}
-}

package/src/services/coupon/types/coupon-params.type.ts

@@ -1,15 +0,0 @@
-import { Checkout, CheckoutTypes, Coupon } from '@infrab4a/connect'
-
-export type CheckCouponParams = {
-  nickname: string
-  checkoutType: CheckoutTypes
-  checkout: Partial<Checkout>
-  plan: string
-}
-
-export type CouponRulesValidationParams = {
-  coupon: Coupon
-  checkoutType: CheckoutTypes
-  checkout: Partial<Checkout>
-  plan: string
-}

package/src/services/coupon.service.ts

@@ -1,347 +0,0 @@
-import { Injectable } from '@angular/core'
-import {
-  Category,
-  Checkout,
-  CheckoutSubscription,
-  CheckoutTypes,
-  Coupon,
-  CouponTypes,
-  Exclusivities,
-  LineItem,
-  Order,
-  OrderStatus,
-  Shops,
-  User,
-  Where,
-} from '@infrab4a/connect'
-import { from, Observable, of } from 'rxjs'
-import { concatMap, map } from 'rxjs/operators'
-
-import { CouponRepositoriesFacade } from './coupon'
-import { CheckCouponParams, CouponRulesValidationParams } from './coupon/types/coupon-params.type'
-import { ConfigurationFacade } from './shared'
-
-@Injectable({
-  providedIn: 'root',
-})
-export class CouponService {
-  constructor(
-    private readonly repositoriesFacade: CouponRepositoriesFacade,
-    private readonly configurationFacade: ConfigurationFacade,
-  ) {}
-
-  checkCoupon(params: CheckCouponParams): Observable<Coupon> {
-    const { nickname, checkoutType, checkout, plan } = params
-
-    return from(
-      this.repositoriesFacade.couponRepository
-        .find({
-          filters: {
-            nickname: { operator: Where.EQUALS, value: nickname },
-            active: { operator: Where.EQUALS, value: true },
-          },
-        })
-        .then((result) => result.data[0]),
-    ).pipe(
-      concatMap((coupon) => this.couponValidation(coupon, checkoutType)),
-      concatMap((couponValid: Coupon) =>
-        this.couponRulesValidation({ coupon: couponValid, checkoutType, checkout, plan }),
-      ),
-      map((couponValidated: Coupon) => couponValidated as Coupon),
-    )
-  }
-
-  private async couponValidation(coupon: Coupon, checkoutType: CheckoutTypes) {
-    if (!coupon) throw 'Cupom inválido.'
-
-    if (coupon?.beginAt && coupon?.beginAt.getTime() > new Date().getTime()) throw 'Cupom inválido.'
-
-    if (coupon?.expiresIn && (coupon?.expiresIn as Date).getTime() < new Date().getTime()) throw 'Cupom expirado.'
-
-    const isInShop =
-      coupon.shopAvailability === Shops.ALL || coupon.shopAvailability === this.configurationFacade.defaultShop
-
-    if (!isInShop) throw 'Cupom inválido para loja.'
-
-    const isCheckoutType = coupon.checkoutType === CheckoutTypes.ALL || coupon.checkoutType === checkoutType
-
-    if (!isCheckoutType) throw 'Cupom inválido. Erro de checkout.'
-
-    return coupon
-  }
-
-  private async couponRulesValidation(params: CouponRulesValidationParams) {
-    const { coupon, checkoutType, checkout, plan } = params
-
-    if (checkoutType == CheckoutTypes.SUBSCRIPTION) {
-      return this.validateSubscriptionCoupon(coupon, plan)
-    }
-
-    return this.validateEcommerceCoupon(coupon, checkoutType, checkout)
-  }
-
-  private validateSubscriptionCoupon(coupon: Coupon, plan: string): Coupon {
-    if (coupon.plan && coupon.plan.toUpperCase() !== plan.toUpperCase()) {
-      throw 'Cupom inválido para sua assinatura.'
-    }
-
-    return coupon
-  }
-
-  private async validateEcommerceCoupon(
-    coupon: Coupon,
-    checkoutType: CheckoutTypes,
-    checkout: Partial<Checkout>,
-  ): Promise<Coupon> {
-    this.validateUserEligibility(coupon, checkout?.user)
-    await this.validateUsageLimits(coupon, checkoutType, checkout)
-    await this.validateProductEligibility(coupon, checkout)
-
-    return coupon
-  }
-
-  private validateUserEligibility(coupon: Coupon, user: User): void {
-    const validUser = this.coupomUserValidation(coupon, user)
-
-    if (!validUser) throw 'Usuário não elegível.'
-  }
-
-  private async validateUsageLimits(
-    coupon: Coupon,
-    checkoutType: CheckoutTypes,
-    checkout: Partial<Checkout>,
-  ): Promise<void> {
-    const couponUseLimits = this.getCouponUseLimits(coupon, checkoutType, checkout.user)
-
-    if (couponUseLimits.firstOrder) {
-      await this.validateFirstOrderLimit(checkout.user.email)
-    }
-
-    if (!couponUseLimits.unlimited || couponUseLimits.limitedPerUser) {
-      await this.validateCouponUsageLimits(coupon, couponUseLimits, checkout.user.email)
-    }
-  }
-
-  private async validateFirstOrderLimit(userEmail: string): Promise<void> {
-    const ordersUser = await this.getOrdersFromUser(userEmail.toLocaleLowerCase())
-
-    if (ordersUser.length >= 1) throw 'Limite de uso atingido'
-  }
-
-  private async validateCouponUsageLimits(coupon: Coupon, couponUseLimits: any, userEmail: string): Promise<void> {
-    const ordersCoupon = await this.getOrdersWithCoupon(coupon)
-
-    if (!couponUseLimits.unlimited && couponUseLimits.total && ordersCoupon.length >= couponUseLimits.total) {
-      throw 'Limite de uso atingido.'
-    }
-
-    if (couponUseLimits.limitedPerUser) {
-      const ordersWithUser = this.countOrdersWithUser(ordersCoupon, userEmail)
-
-      if (ordersWithUser > 0) throw 'Limite de uso por usuário atingido.'
-    }
-  }
-
-  private async validateProductEligibility(coupon: Coupon, checkout: Partial<Checkout>): Promise<void> {
-    const hasProductCategories = await this.hasProductCategories(coupon, checkout)
-
-    if (!hasProductCategories) throw 'Seu carrinho não possui produtos elegíveis para desconto.'
-
-    const hasMinSubTotal = await this.hasMinSubTotal(coupon, checkout)
-
-    if (!hasMinSubTotal) {
-      this.throwMinSubTotalError(coupon)
-    }
-  }
-
-  private throwMinSubTotalError(coupon: Coupon): void {
-    const formattedValue = Intl.NumberFormat('pt-BR', {
-      style: 'currency',
-      currency: 'BRL',
-    }).format(coupon.minSubTotalValue)
-
-    if (coupon.productsCategories?.length) {
-      throw `Valor mínimo de ${formattedValue} não atingido na(s) categoria(s) elegíveis para o desconto.`
-    }
-
-    throw `Valor mínimo de ${formattedValue} não atingido.`
-  }
-
-  public calcDiscountSubscription(coupon: Coupon, checkout: Partial<CheckoutSubscription>): Observable<number> {
-    let discount = 0
-
-    if (coupon.discount.subscription.type == CouponTypes.ABSOLUTE) discount = coupon.discount.subscription.value
-    else discount = checkout.subscriptionPlan.recurrencePrice * (coupon.discount.subscription.value / 100)
-
-    return of(discount)
-  }
-
-  private async hasMinSubTotal(coupon: Coupon, checkout: Partial<Checkout>): Promise<boolean> {
-    if (!coupon.minSubTotalValue) return true
-
-    const lineItensDiscount = await this.getLineItensEligebleForDiscount(coupon.productsCategories, checkout)
-    const subTotal = this.calcCheckoutSubtotal(lineItensDiscount, checkout.user)
-
-    if (coupon.minSubTotalValue <= subTotal) return true
-
-    return false
-  }
-
-  private async hasProductCategories(coupon: Coupon, checkout: Partial<Checkout>): Promise<boolean> {
-    if (!coupon.productsCategories?.length) {
-      return true
-    }
-
-    const couponCategories = await this.getCouponCategoriesId(coupon.productsCategories)
-    const hasCategories = checkout.lineItems?.filter((item) => {
-      if (item.isGift) return false
-
-      if (!item.categories?.length) return true
-
-      return item.categories.some((c) => couponCategories.some((cat) => cat == c))
-    })
-
-    return hasCategories?.length ? true : false
-  }
-
-  private coupomUserValidation(coupon: Coupon, user: User) {
-    if (!user || coupon.exclusivityType.includes(Exclusivities.ALL_USERS)) return true
-
-    const userTypes: Exclusivities[] = []
-
-    if (
-      coupon.exclusivityType.includes(Exclusivities.COLLABORATORS) &&
-      this.emailIsFromCollaborator(user.email.toLocaleLowerCase())
-    )
-      userTypes.push(Exclusivities.COLLABORATORS)
-
-    if (
-      coupon.exclusivityType.includes(Exclusivities.SPECIFIC_USER) &&
-      coupon.userExclusiveEmail.includes(user.email.toLocaleLowerCase())
-    )
-      userTypes.push(Exclusivities.SPECIFIC_USER)
-
-    if (
-      coupon.exclusivityType.includes(Exclusivities.ACTIVE_SUBSCRIBER) &&
-      user.isSubscriber &&
-      user.subscriptionPlan != ''
-    )
-      userTypes.push(Exclusivities.ACTIVE_SUBSCRIBER)
-
-    if (
-      user.isSubscriber &&
-      user.subscriptionPlan == '' &&
-      coupon.exclusivityType.includes(Exclusivities.INACTIVE_SUBSCRIBER)
-    )
-      userTypes.push(Exclusivities.INACTIVE_SUBSCRIBER)
-
-    if (coupon.exclusivityType.includes(Exclusivities.NON_SUBSCRIBER) && !user.isSubscriber)
-      userTypes.push(Exclusivities.NON_SUBSCRIBER)
-
-    return coupon.exclusivityType.some((r) => userTypes.includes(r))
-  }
-
-  private async getCouponCategoriesId(productsCategories: string[]): Promise<Array<String>> {
-    const couponCategories: Array<String> = []
-
-    for (let index = 0; index < productsCategories.length; index++) {
-      const category: Category & { firestoreId?: string } = await this.repositoriesFacade.categoryRepository.get({
-        id: productsCategories[index],
-      })
-
-      if (category) {
-        const children = await this.repositoriesFacade.categoryRepository.getChildren(
-          parseInt(productsCategories[index]),
-        )
-
-        couponCategories.push(category.id, ...children.map((c) => c.id.toString()))
-      }
-    }
-
-    return [...new Set(couponCategories)]
-  }
-
-  private emailIsFromCollaborator = (userEmail: string): boolean => !!userEmail?.match(/@b4a.com.br/g)
-
-  private async getLineItensEligebleForDiscount(
-    productsCategories: string[],
-    checkout: Partial<Checkout>,
-  ): Promise<LineItem[]> {
-    let lineItensDiscount = []
-    const couponCategories = await this.getCouponCategoriesId(productsCategories)
-
-    if (productsCategories?.length) {
-      lineItensDiscount = checkout.lineItems?.filter((item) => {
-        if (item.isGift) return false
-
-        if (item.categories?.length) {
-          return item.categories.some((c) => couponCategories.some((cat) => cat == c))
-        }
-
-        return true
-      })
-    } else {
-      lineItensDiscount = checkout.lineItems.filter((item) => !item.isGift)
-    }
-
-    return lineItensDiscount
-  }
-
-  private calcCheckoutSubtotal(lineItens: LineItem[], user: User): number {
-    return (
-      lineItens
-        ?.filter((item) => !item.isGift)
-        .reduce(
-          (acc, curr) =>
-            user?.isSubscriber && curr.price?.subscriberPrice
-              ? acc + curr.price?.subscriberPrice * curr.quantity
-              : acc + curr.pricePaid * curr.quantity,
-          0,
-        ) || 0
-    )
-  }
-
-  private async getOrdersWithCoupon(coupon: Coupon): Promise<Order[]> {
-    return await this.repositoriesFacade.orderRepository
-      .find({
-        filters: {
-          coupon: { id: coupon.id },
-          status: { operator: Where.NOTEQUALS, value: OrderStatus.CANCELADO },
-        },
-      })
-      .then((result) => result.data)
-  }
-
-  private async getOrdersFromUser(email: string) {
-    return await this.repositoriesFacade.orderRepository
-      .find({
-        filters: {
-          user: { email: { operator: Where.EQUALS, value: email } },
-          status: { operator: Where.NOTEQUALS, value: OrderStatus.CANCELADO },
-        },
-      })
-      .then((result) => result.data)
-  }
-
-  private countOrdersWithUser(orders: Order[], email: string): number {
-    return orders.filter((o) => o.user.email == email).length
-  }
-
-  private getCouponUseLimits(coupon: Coupon, checkoutType: CheckoutTypes, user: User) {
-    let couponUseLimits: { unlimited?: boolean; total?: number; limitedPerUser?: boolean; firstOrder?: boolean }
-
-    if (checkoutType == CheckoutTypes.ECOMMERCE || checkoutType == CheckoutTypes.ALL) {
-      if (
-        coupon.exclusivityType.length === 1 &&
-        (coupon.exclusivityType.at(0) === Exclusivities.SPECIFIC_USER ||
-          coupon.exclusivityType.at(0) === Exclusivities.COLLABORATORS)
-      )
-        couponUseLimits = coupon.useLimits.non_subscriber
-      else couponUseLimits = user?.isSubscriber ? coupon.useLimits.subscriber : coupon.useLimits.non_subscriber
-    } else {
-      couponUseLimits = coupon.useLimits.subscription
-    }
-
-    return couponUseLimits
-  }
-}

package/src/services/errors/group-invalid-coupon.error.ts

@@ -1,9 +0,0 @@
-import { CustomError } from 'ts-custom-error'
-
-import { InvalidCouponError } from './invalid-coupon.error'
-
-export class GroupInvalidCouponError extends CustomError {
-  constructor(readonly errors: InvalidCouponError[]) {
-    super('Many coupon errors throw')
-  }
-}

package/src/services/errors/index.ts

@@ -1,2 +0,0 @@
-export * from './group-invalid-coupon.error'
-export * from './invalid-coupon.error'

package/src/services/errors/invalid-coupon.error.ts

@@ -1,7 +0,0 @@
-import { CustomError } from 'ts-custom-error'
-
-export class InvalidCouponError extends CustomError {
-  constructor(message: string) {
-    super(message)
-  }
-}

package/src/services/helpers/index.ts

@@ -1 +0,0 @@
-export * from './util.helper'