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

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,124 +0,0 @@
-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 { RequiredCheckoutData } from './types'
-import { CartServicesFacade } from './cart'
-import { ConfigurationFacade } from './shared'
-
-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): Observable<Cart> {
-    return this.servicesFacade.checkoutService.getCheckout().pipe(
-      concatMap((checkout) =>
-        this.servicesFacade.httpClient.post(`${this.checkoutUrl}/checkoutAddItemToCart`, {
-          checkoutId: checkout.id,
-          productId: item.id,
-          quantity,
-        }),
-      ),
-      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(
-    @Inject('CatalogSearchContext') private readonly searchContext: CatalogSearchContext,
-    @Inject('CatalogHelpersService') 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,52 +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(
-    @Inject('CategoryRepositoryFacade') private readonly categoryFacade: CategoryRepositoryFacade,
-    @Inject('ProductCatalogFacade') 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.productRepository
-      .findCatalog(
-        {
-          filters: await this.productCatalog.categoryStructureAdapter.buildProductFilterByCategory(category),
-          fields: ['brand'],
-        },
-        options?.mainGender ? options?.mainGender : this.shop === Shops.MENSMARKET ? 'male' : 'female',
-        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 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))
-  }
-}

package/src/services/catalog/context/catalog-search.context.ts

@@ -1,61 +0,0 @@
-import { Injectable } from '@angular/core'
-import { Product, RepositoryCacheOptions, RepositoryFindResult, Shops } from '@infrab4a/connect'
-
-import { CatalogSearchParams, CatalogSearchStrategy } from '../../../interfaces'
-
-@Injectable()
-export class CatalogSearchContext {
-  private strategies = new Map<string, CatalogSearchStrategy>()
-
-  constructor(
-    private readonly categoryStrategy: CatalogSearchStrategy,
-    private readonly termStrategy: CatalogSearchStrategy,
-    private readonly profileStrategy: CatalogSearchStrategy,
-  ) {
-    this.initializeStrategies()
-  }
-
-  async executeSearch(
-    params: CatalogSearchParams,
-    shop: Shops,
-    optionsCache?: { cache?: RepositoryCacheOptions },
-  ): Promise<RepositoryFindResult<Product>> {
-    const strategy = this.selectStrategy(params)
-
-    return strategy.search(params, shop, optionsCache)
-  }
-
-  private initializeStrategies(): void {
-    this.strategies.set('category', this.categoryStrategy)
-    this.strategies.set('term', this.termStrategy)
-    this.strategies.set('profile', this.profileStrategy)
-  }
-
-  private selectStrategy(params: CatalogSearchParams): CatalogSearchStrategy {
-    if (params.category) {
-      const strategy = this.strategies.get('category')
-
-      if (!strategy) throw new Error('Category strategy not found')
-
-      return strategy
-    }
-
-    if (params.term) {
-      const strategy = this.strategies.get('term')
-
-      if (!strategy) throw new Error('Term strategy not found')
-
-      return strategy
-    }
-
-    if (params.profile?.length) {
-      const strategy = this.strategies.get('profile')
-
-      if (!strategy) throw new Error('Profile strategy not found')
-
-      return strategy
-    }
-
-    throw new Error('No valid search strategy found for the given parameters')
-  }
-}

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

@@ -1 +0,0 @@
-export * from './product-sorts.enum'

package/src/services/catalog/enums/product-sorts.enum.ts

@@ -1,9 +0,0 @@
-export enum ProductSorts {
-  MOST_RELEVANT = 'most-relevant',
-  BEST_SELLER = 'best-sellers',
-  BIGGEST_PRICE = 'biggest-price',
-  LOWEST_PRICE = 'lowest-price',
-  BIGGEST_DISCOUNT = 'biggest-discount',
-  BEST_RATING = 'best-rating',
-  NEWS = 'news',
-}

package/src/services/catalog/facades/catalog-service.facade.ts

@@ -1,32 +0,0 @@
-import { Inject, Injectable } from '@angular/core'
-import { Shops } from '@infrab4a/connect'
-
-import { DEFAULT_SHOP } from '../../../consts'
-import { CatalogService } from '../catalog.service'
-import { CatalogSearchContext } from '../context/catalog-search.context'
-import { CatalogHelpersService } from '../services'
-
-import { CatalogStrategiesFacade } from './catalog-strategies.facade'
-
-@Injectable()
-export class CatalogServiceFacade {
-  private catalogService: CatalogService
-
-  constructor(
-    private readonly helpersService: CatalogHelpersService,
-    private readonly strategiesFacade: CatalogStrategiesFacade,
-    @Inject(DEFAULT_SHOP) private readonly shop: Shops,
-  ) {
-    const searchContext = new CatalogSearchContext(
-      this.strategiesFacade.categoryStrategy,
-      this.strategiesFacade.termStrategy,
-      this.strategiesFacade.profileStrategy,
-    )
-
-    this.catalogService = new CatalogService(searchContext, this.helpersService, this.shop)
-  }
-
-  getCatalogService(): CatalogService {
-    return this.catalogService
-  }
-}

package/src/services/catalog/facades/catalog-strategies.facade.ts

@@ -1,12 +0,0 @@
-import { Injectable } from '@angular/core'
-
-import { CategorySearchStrategy, ProfileSearchStrategy, TermSearchStrategy } from '../strategies'
-
-@Injectable()
-export class CatalogStrategiesFacade {
-  constructor(
-    public readonly categoryStrategy: CategorySearchStrategy,
-    public readonly termStrategy: TermSearchStrategy,
-    public readonly profileStrategy: ProfileSearchStrategy,
-  ) {}
-}

package/src/services/catalog/facades/category-repository.facade.ts

@@ -1,10 +0,0 @@
-import { Inject, Injectable } from '@angular/core'
-import { CategoryFilterRepository, CategoryRepository } from '@infrab4a/connect'
-
-@Injectable()
-export class CategoryRepositoryFacade {
-  constructor(
-    @Inject('CategoryRepository') public readonly categoryRepository: CategoryRepository,
-    @Inject('CategoryFilterRepository') public readonly categoryFilterRepository: CategoryFilterRepository,
-  ) {}
-}