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

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

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

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

package/src/interfaces/index.ts

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

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

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

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

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

package/src/services/auth.service.ts

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

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

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

package/src/services/cart.service.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,10 @@
+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,
+  ) {}
+}