@infrab4a/connect-angular 5.8.12 → 5.8.13

package/src/consts/category-structure.ts

@@ -1 +0,0 @@
-export const CATEGORY_STRUCTURE = 'CATEGORY_STRUCTURE'

package/src/consts/default-shop.const.ts

@@ -1 +0,0 @@
-export const DEFAULT_SHOP = 'DEFAULT_SHOP'

package/src/consts/es-config.const.ts

@@ -1 +0,0 @@
-export const ES_CONFIG = 'ES_CONFIG'

package/src/consts/firebase-const.ts

@@ -1,5 +0,0 @@
-import { InjectionToken } from '@angular/core'
-
-export const FIREBASE_APP_NAME = new InjectionToken('firebaseAppName')
-export const FIREBASE_OPTIONS = new InjectionToken('firebaseOptions')
-export const APP_CHECK_PROVIDER = new InjectionToken('appCheckProvider')

package/src/consts/hasura-options.const.ts

@@ -1 +0,0 @@
-export const HASURA_OPTIONS = 'HASURA_OPTIONS'

package/src/consts/index.ts

@@ -1,8 +0,0 @@
-export * from './backend-url.const'
-export * from './category-structure'
-export * from './default-shop.const'
-export * from './es-config.const'
-export * from './firebase-const'
-export * from './hasura-options.const'
-export * from './persistence.const'
-export * from './vertex-config.const'

package/src/consts/persistence.const.ts

@@ -1 +0,0 @@
-export const PERSISTENCE_PROVIDER = 'PERSISTENCE_PROVIDER'

package/src/consts/storage-base-url.const.ts

@@ -1 +0,0 @@
-export const STORAGE_BASE_URL = 'STORAGE_BASE_URL'

package/src/consts/vertex-config.const.ts

@@ -1 +0,0 @@
-export const VERTEX_CONFIG = 'VERTEX_CONFIG'

package/src/helpers/index.ts

@@ -1 +0,0 @@
-export * from './mobile-operation-system-checker.helper'

package/src/helpers/mobile-operation-system-checker.helper.ts

@@ -1,10 +0,0 @@
-export class MobileOperationSystemCheckerHelper {
-  static isAppleDevice() {
-    return (
-      ['iPad Simulator', 'iPhone Simulator', 'iPod Simulator', 'iPad', 'iPhone', 'iPod'].includes(
-        navigator?.platform,
-      ) ||
-      (navigator?.userAgent?.includes?.('Mac') && 'ontouchend' in (document || {}))
-    )
-  }
-}

package/src/index.ts

@@ -1,6 +0,0 @@
-export * from './angular-connect.module'
-export * from './angular-firebase-auth.module'
-export * from './angular-firestore.module'
-export * from './angular-hasura-graphql.module'
-export * from './persistence'
-export * from './services'

package/src/interfaces/catalog-strategies.interface.ts

@@ -1,36 +0,0 @@
-import {
-  Category,
-  Product,
-  ProductGender,
-  RepositoryCacheOptions,
-  RepositoryFindResult,
-  Shops,
-} from '@infrab4a/connect'
-
-export interface CatalogSearchParams {
-  category?: Category
-  profile?: string[]
-  term?: string
-  filters?: CatalogFilters
-  mainGender?: ProductGender
-  limits: { limit?: number; offset?: number }
-  sort?: string
-}
-
-export interface CatalogFilters {
-  clubDiscount?: number[]
-  brands?: string[]
-  prices?: { min?: number; max?: number; subscriberPrice?: boolean }
-  gender?: ProductGender[]
-  rate?: number
-  customOptions?: string[]
-  tags?: string[]
-}
-
-export interface CatalogSearchStrategy {
-  search(
-    params: CatalogSearchParams,
-    shop: Shops,
-    optionsCache?: { cache?: RepositoryCacheOptions },
-  ): Promise<RepositoryFindResult<Product>>
-}

package/src/interfaces/category-facades.interface.ts

@@ -1,7 +0,0 @@
-import { CategoryRepository, ProductSearchIndex, ProductStockNotificationRepository } from '@infrab4a/connect'
-
-export interface ProductServicesFacade {
-  productStockNotificationRepository: ProductStockNotificationRepository
-  categoryRepository: CategoryRepository
-  productSearch: ProductSearchIndex
-}

package/src/interfaces/index.ts

@@ -1,2 +0,0 @@
-export * from './catalog-strategies.interface'
-export * from './category-facades.interface'

package/src/persistence/cookie-data-persistence.ts

@@ -1,21 +0,0 @@
-import { Injectable } from '@angular/core'
-import cookie from 'js-cookie'
-import { Observable, from, of } from 'rxjs'
-import { map } from 'rxjs/operators'
-
-import { DataPersistence } from './data-persistence'
-
-@Injectable()
-export class CookieDataPersistence implements DataPersistence {
-  get(key: string): Observable<string> {
-    return of(cookie.get(key))
-  }
-
-  remove(key: string): Observable<void> {
-    return of(cookie.remove(key))
-  }
-
-  set(key: string, value: string): Observable<void> {
-    return from(cookie.set(key, value)).pipe(map(() => {}))
-  }
-}

package/src/persistence/data-persistence.ts

@@ -1,7 +0,0 @@
-import { Observable } from 'rxjs'
-
-export interface DataPersistence {
-  get(key: string): Observable<string>
-  remove(key: string): Observable<void>
-  set(key: string, value: string): Observable<void>
-}

package/src/persistence/index.ts

@@ -1,2 +0,0 @@
-export * from './cookie-data-persistence'
-export * from './data-persistence'

package/src/services/auth.service.ts

@@ -1,39 +0,0 @@
-import { Inject, Injectable } from '@angular/core'
-import { Auth, User as FirebaseUser, authState, getIdToken } from '@angular/fire/auth'
-import { User, UserRepository } from '@infrab4a/connect'
-import { Observable, combineLatest, from, of } from 'rxjs'
-import { catchError, map, mergeMap } from 'rxjs/operators'
-
-@Injectable()
-export class AuthService {
-  constructor(
-    private readonly angularFireAuth: Auth,
-    @Inject('UserRepository') private readonly userRepository: UserRepository,
-  ) {}
-
-  getAuthstate(): Observable<{ user: User; isAnonymous: boolean }> {
-    const observables: [Observable<FirebaseUser>, Observable<User>] = [this.getFireUser(), this.getUser()]
-
-    return combineLatest(observables).pipe(
-      map(([fireUser, user]) => ({
-        user,
-        isAnonymous: fireUser?.isAnonymous,
-      })),
-    )
-  }
-
-  getUser(): Observable<User> {
-    return this.getFireUser().pipe(
-      map((user) => user?.uid),
-      mergeMap((id) => (id ? from(this.userRepository.get({ id })).pipe(catchError(() => of(null))) : of(null))),
-    )
-  }
-
-  getTokenId(): Observable<string> {
-    return from(getIdToken(this.angularFireAuth.currentUser))
-  }
-
-  getFireUser(): Observable<FirebaseUser> {
-    return authState(this.angularFireAuth).pipe(catchError(() => of(null)))
-  }
-}

package/src/services/cart/cart-services.facade.ts

@@ -1,14 +0,0 @@
-import { HttpClient } from '@angular/common/http'
-import { Injectable } from '@angular/core'
-
-import { AuthService } from '../auth.service'
-import { CheckoutService } from '../checkout.service'
-
-@Injectable()
-export class CartServicesFacade {
-  constructor(
-    public readonly authService: AuthService,
-    public readonly checkoutService: CheckoutService,
-    public readonly httpClient: HttpClient,
-  ) {}
-}

package/src/services/cart/index.ts

@@ -1 +0,0 @@
-export { CartServicesFacade } from './cart-services.facade'

package/src/services/cart.service.ts

@@ -1,148 +0,0 @@
-/* eslint-disable max-params */
-import { Injectable } from '@angular/core'
-import { Checkout, LineItem, User } from '@infrab4a/connect'
-import { Observable, of, Subject } from 'rxjs'
-import { concatMap, map, tap } from 'rxjs/operators'
-
-import { CartServicesFacade } from './cart'
-import { ConfigurationFacade } from './shared'
-import { RequiredCheckoutData } from './types'
-
-export type Cart = {
-  [id: string]: LineItem
-}
-
-@Injectable()
-export class CartService {
-  private cartSubject: Subject<Cart> = new Subject()
-  private checkoutUrl: string = null
-
-  constructor(
-    private readonly servicesFacade: CartServicesFacade,
-    private readonly configurationFacade: ConfigurationFacade,
-  ) {
-    this.checkoutUrl = this.configurationFacade.getCheckoutUrl()
-  }
-
-  addItem(
-    item: LineItem,
-    quantity: number = 1,
-    recurrence: boolean = false,
-    recurrenceCycle: string = null,
-  ): Observable<Cart> {
-    return this.servicesFacade.checkoutService.getCheckout().pipe(
-      concatMap((checkout) =>
-        this.servicesFacade.httpClient.post(`${this.checkoutUrl}/checkoutAddItemToCart`, {
-          checkoutId: checkout.id,
-          productId: item.id,
-          quantity,
-          recurrence,
-          recurrenceCycle,
-        }),
-      ),
-      concatMap(() => this.servicesFacade.checkoutService.getCheckout()),
-      map((updatedCheckout) => this.generateCartObject(updatedCheckout.lineItems)),
-      tap((cart) => this.cartSubject.next(cart)),
-    )
-  }
-
-  updateItemRecurrence(item: LineItem, recurrence: boolean = false, recurrenceCycle: string = null): Observable<Cart> {
-    return this.servicesFacade.checkoutService.getCheckout().pipe(
-      concatMap((checkout) =>
-        this.servicesFacade.httpClient.post(`${this.checkoutUrl}/checkoutUpdateItemRecurrence`, {
-          checkoutId: checkout.id,
-          productId: item.id,
-          recurrence,
-          recurrenceCycle,
-        }),
-      ),
-      concatMap(() => this.servicesFacade.checkoutService.getCheckout()),
-      map((updatedCheckout) => this.generateCartObject(updatedCheckout.lineItems)),
-      tap((cart) => this.cartSubject.next(cart)),
-    )
-  }
-
-  decreaseItem(item: LineItem): Observable<Cart> {
-    return this.servicesFacade.checkoutService.getCheckout().pipe(
-      concatMap((checkout) =>
-        this.servicesFacade.httpClient.post(`${this.checkoutUrl}/checkoutDecreaseProductFromCart`, {
-          checkoutId: checkout.id,
-          productId: item.id,
-          quantity: 1,
-        }),
-      ),
-      concatMap(() => this.servicesFacade.checkoutService.getCheckout()),
-      map((updatedCheckout) => this.generateCartObject(updatedCheckout.lineItems)),
-      tap((cart) => this.cartSubject.next(cart)),
-    )
-  }
-
-  removeItem(item: LineItem): Observable<Cart> {
-    return this.servicesFacade.checkoutService.getCheckout().pipe(
-      concatMap((checkout) =>
-        this.servicesFacade.httpClient.post(`${this.checkoutUrl}/checkoutRemoveProductFromCart`, {
-          checkoutId: checkout.id,
-          productId: item.id,
-        }),
-      ),
-      concatMap(() => this.servicesFacade.checkoutService.getCheckout()),
-      map((updatedCheckout) => this.generateCartObject(updatedCheckout.lineItems)),
-      tap((cart) => this.cartSubject.next(cart)),
-    )
-  }
-
-  updateUserCart(user: User): Observable<Cart> {
-    return this.servicesFacade.checkoutService.getCheckout().pipe(
-      concatMap((checkout) =>
-        this.servicesFacade.checkoutService.updateCheckoutUser(Checkout.toInstance({ ...checkout.toPlain(), user })),
-      ),
-      concatMap((checkout) => {
-        return this.servicesFacade.httpClient.post(`${this.checkoutUrl}/checkoutUpdateUserCart`, {
-          checkoutId: checkout.id,
-        })
-      }),
-      concatMap(() => this.servicesFacade.checkoutService.getCheckout()),
-      map((updatedCheckout) => {
-        return this.generateCartObject(updatedCheckout.lineItems)
-      }),
-      tap((cart) => this.cartSubject.next(cart)),
-    )
-  }
-
-  getCart(checkout?: RequiredCheckoutData): Observable<Cart> {
-    this.buildCartFromCheckout(checkout).subscribe((cart) => this.cartSubject.next(cart))
-
-    return this.cartSubject
-  }
-
-  clearCart(): Observable<Cart> {
-    return this.servicesFacade.checkoutService.getCheckout().pipe(
-      map((checkout) => {
-        this.servicesFacade.checkoutService.clearCheckoutFromSession()
-
-        return checkout
-      }),
-      concatMap((oldCheckout) => this.buildCartFromCheckout(oldCheckout)),
-      tap((cart) => this.cartSubject.next(cart)),
-    )
-  }
-
-  private buildCartFromCheckout(checkoutData?: RequiredCheckoutData): Observable<Cart> {
-    return this.servicesFacade.checkoutService.getCheckout(checkoutData).pipe(
-      map((checkout) => checkout.lineItems),
-      concatMap((lineItems) => of(this.generateCartObject(lineItems))),
-    )
-  }
-
-  private generateCartObject = (items: LineItem[]): Cart =>
-    items?.reduce(
-      (cart, item) => ({
-        ...cart,
-        [item.id]: LineItem.toInstance({
-          ...(cart[item.id] || item),
-          quantity: (cart[item.id]?.quantity || 0) + (item.quantity ? item.quantity : 1),
-        }),
-      }),
-      {} as Record<string, LineItem>,
-    ) || {}
-}

package/src/services/catalog/adapters/category-structure.adapter.ts

@@ -1,5 +0,0 @@
-import { Category, Product, RepositoryFindFielters } from '@infrab4a/connect/'
-
-export interface CategoryStructureAdapter {
-  buildProductFilterByCategory(category: Category): Promise<RepositoryFindFielters<Product>>
-}

package/src/services/catalog/adapters/index.ts

@@ -1,3 +0,0 @@
-export * from './category-structure.adapter'
-export * from './new-category-structure.adapter'
-export * from './old-category-structure.adapter'

package/src/services/catalog/adapters/new-category-structure.adapter.ts

@@ -1,42 +0,0 @@
-import { Inject, Injectable } from '@angular/core'
-import { Category, CategoryRepository, isNil, Product, RepositoryFindFielters, Where } from '@infrab4a/connect'
-
-import { CategoryStructureAdapter } from './category-structure.adapter'
-
-@Injectable()
-export class NewCategoryStructureAdapter implements CategoryStructureAdapter {
-  constructor(@Inject('CategoryRepository') private readonly categoryRepository: CategoryRepository) {}
-
-  async buildProductFilterByCategory(category: Category): Promise<RepositoryFindFielters<Product>> {
-    const loadedCategory = await this.getCategory(category)
-
-    if (loadedCategory.isCollection) return { id: { operator: Where.IN, value: loadedCategory.products } }
-
-    const categoryIds = [...(await this.getAllCategoriesIdFromCategory(category)), category.id.toString()]
-
-    return {
-      category: {
-        id: {
-          operator: Where.IN,
-          value: categoryIds,
-        },
-      },
-    }
-  }
-
-  private async getAllCategoriesIdFromCategory(category: Category): Promise<string[]> {
-    return this.categoryRepository
-      .getChildren(+category.id)
-      .then((categories) => categories.map((category) => category.id.toString()))
-  }
-
-  private async getCategory(category: Category): Promise<Category> {
-    const collectionCategory =
-      category.isCollection ||
-      (isNil(category.isCollection) && !category.products?.length) ||
-      category.isWishlist ||
-      category.brandCategory
-
-    return collectionCategory ? this.categoryRepository.get({ id: category.id }) : category
-  }
-}

package/src/services/catalog/adapters/old-category-structure.adapter.ts

@@ -1,17 +0,0 @@
-import { Inject, Injectable } from '@angular/core'
-import { Category, CategoryRepository, Product, RepositoryFindFielters, Where } from '@infrab4a/connect'
-
-import { CategoryStructureAdapter } from './category-structure.adapter'
-
-@Injectable()
-export class OldCategoryStructureAdapter implements CategoryStructureAdapter {
-  constructor(@Inject('CategoryRepository') private readonly categoryRepository: CategoryRepository) {}
-
-  async buildProductFilterByCategory(category: Category): Promise<RepositoryFindFielters<Product>> {
-    const productsIds = category.products?.length
-      ? category.products
-      : await this.categoryRepository.get({ id: category.id }).then((categoryFound) => categoryFound.products)
-
-    return { id: { operator: Where.IN, value: productsIds } }
-  }
-}

package/src/services/catalog/catalog.service.ts

@@ -1,153 +0,0 @@
-import { Inject, Injectable } from '@angular/core'
-import {
-  Category,
-  InvalidArgumentError,
-  RepositoryCacheOptions,
-  RoundProductPricesHelper,
-  Shops,
-} from '@infrab4a/connect'
-
-import { DEFAULT_SHOP } from '../../consts'
-import { CatalogFilters, CatalogSearchParams } from '../../interfaces'
-
-import { CatalogSearchContext } from './context/catalog-search.context'
-import { CatalogHelpersService } from './services'
-import {
-  BuildResponseParams,
-  FetchProductsMainParams,
-  FetchProductsOptions,
-  FetchProductsParams,
-  FetchProductsResponse,
-  StockNotificationParams,
-} from './types'
-
-@Injectable()
-export class CatalogService<T extends Category = Category> {
-  constructor(
-    private readonly searchContext: CatalogSearchContext,
-    private readonly helpersService: CatalogHelpersService,
-    @Inject(DEFAULT_SHOP) private readonly shop: Shops,
-  ) {}
-
-  async fetchProducts(
-    options: FetchProductsParams<T>,
-    optionsCache?: { cache?: RepositoryCacheOptions },
-  ): Promise<FetchProductsResponse> {
-    this.validateRequest(options)
-
-    const searchParams = this.buildSearchParams(options)
-    const {
-      data,
-      count: total,
-      maximum,
-      minimal,
-      distinct,
-    } = await this.searchContext.executeSearch(searchParams, this.shop, optionsCache)
-
-    await this.helpersService.getBrandManager().setBrandsList(searchParams, distinct?.brand)
-
-    return this.buildResponse({
-      data,
-      total,
-      maximum,
-      minimal,
-      searchParams,
-      options,
-    })
-  }
-
-  async addCustomerToStockNotification(params: StockNotificationParams): Promise<void> {
-    const { shop, productId, name, email } = params
-    const productServices = this.helpersService.getProductServices()
-
-    return productServices.productStockNotificationRepository.addCustomerEmail({
-      shop,
-      productId,
-      name,
-      email,
-    })
-  }
-
-  private validateRequest(options: FetchProductsParams<T>): void {
-    if (this.hasProfile(options) && options.filters?.customOptions) {
-      throw new InvalidArgumentError(`It couldn't filled customOptions when profile is given`)
-    }
-
-    if (this.hasProfile(options) && options.filters?.tags) {
-      throw new InvalidArgumentError(`It couldn't filled tags when profile is given`)
-    }
-
-    if (this.hasTerm(options) && options.filters?.customOptions) {
-      throw new InvalidArgumentError(`It couldn't filled customOptions when term is given`)
-    }
-  }
-
-  private buildSearchParams(options: FetchProductsParams<T>): CatalogSearchParams {
-    const limits = this.buildLimitQuery(options)
-
-    return {
-      category: this.hasCategory(options) ? options.category : undefined,
-      profile: this.hasProfile(options) ? options.profile : undefined,
-      term: this.hasTerm(options) ? options.term : undefined,
-      filters: options.filters,
-      mainGender: options.mainGender,
-      sort: options.sort,
-      limits,
-    }
-  }
-
-  private buildResponse(params: BuildResponseParams<T>): FetchProductsResponse {
-    const { data, total, maximum, minimal, searchParams } = params
-    const limits = searchParams.limits
-    const indexKey = this.helpersService.getBrandManager().buildIndexBrands(searchParams)
-
-    return {
-      products: {
-        data: data.map((product) => RoundProductPricesHelper.roundProductPrices(product)),
-        total,
-      },
-      pages: Math.ceil(total / limits.limit),
-      prices: {
-        price: {
-          min: +(minimal?.price?.price?.toFixed(2) || 0),
-          max: +(maximum?.price?.price?.toFixed(2) || 0),
-        },
-        subscriberPrice: {
-          min: +(minimal?.price?.subscriberPrice?.toFixed(2) || 0),
-          max: +(maximum?.price?.subscriberPrice?.toFixed(2) || 0),
-        },
-      },
-      brands: this.helpersService.getBrandManager().getBrandsList(indexKey),
-    }
-  }
-
-  private buildLimitQuery(options: { page?: number; perPage?: number }): { limit: number; offset: number } {
-    const limit = options?.perPage || 20
-
-    return {
-      limit,
-      offset: ((options?.page || 1) - 1) * limit,
-    }
-  }
-
-  private hasProfile(options: Partial<FetchProductsParams<T>>): options is FetchProductsOptions & {
-    profile: FetchProductsMainParams<T>['profile']
-    filters?: CatalogFilters & { customOptions?: never; tags?: never }
-  } {
-    return 'profile' in options
-  }
-
-  private hasTerm(options: Partial<FetchProductsParams<T>>): options is FetchProductsOptions & {
-    term: FetchProductsMainParams<T>['term']
-    filters?: CatalogFilters & { customOptions?: never }
-  } {
-    return 'term' in options
-  }
-
-  private hasCategory(options: Partial<FetchProductsParams<T>>): options is FetchProductsOptions & {
-    category: FetchProductsMainParams<T>['category']
-    filters?: CatalogFilters & { customOptions?: never }
-  } {
-    return 'category' in options
-  }
-}

package/src/services/catalog/category.service.ts

@@ -1,56 +0,0 @@
-import { Inject, Injectable } from '@angular/core'
-import { Category, Filter, ProductGender, RepositoryCacheOptions, Shops } from '@infrab4a/connect'
-
-import { DEFAULT_SHOP } from '../../consts'
-
-import { CategoryRepositoryFacade, ProductCatalogFacade } from './facades'
-
-type FetchBrandsOptions = {
-  mainGender?: ProductGender
-  shop?: Shops
-}
-
-@Injectable()
-export class CategoryService {
-  constructor(
-    private readonly categoryFacade: CategoryRepositoryFacade,
-    private readonly productCatalog: ProductCatalogFacade,
-    @Inject(DEFAULT_SHOP) private readonly shop: Shops,
-  ) {}
-
-  async fetchBrands(
-    category: Category,
-    options?: FetchBrandsOptions,
-    optionsCache?: { cache?: RepositoryCacheOptions },
-  ): Promise<Category[]> {
-    const brands = await this.productCatalog.productCatalogRepository
-      .findCatalog(
-        {
-          filters: await this.productCatalog.categoryStructureAdapter.buildProductFilterByCategory(category),
-          fields: ['brand'],
-        },
-        null,
-        optionsCache,
-      )
-      .then(({ data }) =>
-        Object.keys(data.map((product) => product.brand).reduce((brands, brand) => ({ ...brands, [brand]: true }), {})),
-      )
-
-    return this.categoryFacade.categoryRepository
-      .find(
-        { filters: { brandCategory: true, shop: options?.shop || this.shop }, orderBy: { name: 'asc' } },
-        optionsCache,
-      )
-      .then(({ data }) => data.filter((category) => brands.includes(category.conditions.brand)))
-  }
-
-  async getMenuBrands() {
-    return this.categoryFacade.categoryRepository.getBrandsWithProducts()
-  }
-
-  async fetchFilterOptions(category: Category, optionsCache?: { cache?: RepositoryCacheOptions }): Promise<Filter[]> {
-    return await this.categoryFacade.categoryFilterRepository
-      .find({ filters: { categoryId: +category.id } }, optionsCache)
-      .then(({ data }) => data.map((categoryFilter) => categoryFilter.filter))
-  }
-}