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

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

@@ -0,0 +1,10 @@
+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/index.ts

@@ -0,0 +1,2 @@
+export { CheckoutRepositoriesFacade } from './checkout-repositories.facade'
+export { CheckoutDependenciesFacade } from './checkout-dependencies.facade'

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

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

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

@@ -0,0 +1,11 @@
+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/index.ts

@@ -0,0 +1 @@
+export { CouponRepositoriesFacade } from './coupon-repositories.facade'

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

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

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

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

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

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

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

package/src/services/helpers/index.ts

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