@infrab4a/connect-angular 5.8.16 → 5.8.20

package/src/services/catalog/strategies/category-search.strategy.spec.ts

@@ -0,0 +1,93 @@
+import { Category, Product, RepositoryFindResult, Shops, Where } from '@infrab4a/connect'
+
+import { CatalogFilterHelper } from '../helpers/catalog-filter.helper'
+import { CatalogSortHelper } from '../helpers/catalog-sort.helper'
+import { ProductFieldsHelper } from '../helpers/product-fields.helper'
+import { CatalogHelpersService, CatalogRepositoryService } from '../services'
+
+import { CategorySearchStrategy } from './category-search.strategy'
+
+describe('CategorySearchStrategy', () => {
+  let findCatalog: jasmine.Spy
+  let buildProductFilterByCategory: jasmine.Spy
+  let strategy: CategorySearchStrategy
+  const limits = { limit: 24, offset: 0 }
+  const shop = Shops.GLAMSHOP
+  const emptyResult: RepositoryFindResult<Product> = {
+    data: [],
+    count: 0,
+  }
+
+  beforeEach(() => {
+    findCatalog = jasmine.createSpy('findCatalog').and.resolveTo(emptyResult)
+    buildProductFilterByCategory = jasmine
+      .createSpy('buildProductFilterByCategory')
+      .and.resolveTo({ id: { operator: Where.IN, value: ['1', '2'] } })
+
+    const repositoryService = {
+      getProductCatalog: () => ({
+        productCatalogRepository: { findCatalog },
+        categoryStructureAdapter: { buildProductFilterByCategory },
+      }),
+    } as unknown as CatalogRepositoryService
+
+    const helpersService = {
+      getFieldsHelper: () => new ProductFieldsHelper(),
+      getFilterHelper: () => new CatalogFilterHelper(),
+      getSortHelper: () => new CatalogSortHelper(),
+    } as unknown as CatalogHelpersService
+
+    strategy = new CategorySearchStrategy(repositoryService, helpersService)
+  })
+
+  it('should paginate wishlist most-relevant as best-sellers in the catalog query', async () => {
+    const category = { id: '10', isWishlist: true, products: ['1', '2'] } as Category
+
+    await strategy.search({ category, filters: {}, limits, sort: 'most-relevant' }, shop)
+
+    expect(findCatalog).toHaveBeenCalledTimes(1)
+
+    const [repoParams, mainGender] = findCatalog.calls.mostRecent().args
+
+    expect(repoParams.limits).toEqual(limits)
+    expect(repoParams.orderBy).toEqual({
+      shoppingCount: 'desc',
+      rate: 'desc',
+      stock: 'desc',
+      name: 'asc',
+    })
+    expect(repoParams.fields).not.toEqual(['id'])
+    expect(mainGender).toBeNull()
+  })
+
+  it('should keep most-relevant in-memory path when category is not a wishlist', async () => {
+    const category = {
+      id: '20',
+      isWishlist: false,
+      getMostRelevantByShop: () => ['1'],
+    } as unknown as Category
+
+    await strategy.search({ category, filters: {}, limits, sort: 'most-relevant' }, shop)
+
+    expect(findCatalog).toHaveBeenCalledTimes(2)
+    expect(findCatalog.calls.argsFor(0)[0].fields).toEqual(['id'])
+    expect(findCatalog.calls.argsFor(0)[0].limits).toBeUndefined()
+    expect(findCatalog.calls.argsFor(1)[0].orderBy).toEqual({
+      shoppingCount: 'desc',
+      rate: 'desc',
+      stock: 'desc',
+      name: 'asc',
+    })
+    expect(findCatalog.calls.argsFor(1)[0].limits).toBeUndefined()
+  })
+
+  it('should use the requested sort when wishlist sort is not most-relevant', async () => {
+    const category = { id: '10', isWishlist: true, products: ['1'] } as Category
+
+    await strategy.search({ category, filters: {}, limits, sort: 'news' }, shop)
+
+    expect(findCatalog).toHaveBeenCalledTimes(1)
+    expect(findCatalog.calls.mostRecent().args[0].orderBy).toEqual({ createdAt: 'desc' })
+    expect(findCatalog.calls.mostRecent().args[0].limits).toEqual(limits)
+  })
+})

package/src/services/catalog/strategies/category-search.strategy.ts

@@ -0,0 +1,181 @@
+import { Injectable } from '@angular/core'
+import { isEmpty, Product, RepositoryCacheOptions, RepositoryFindResult, Shops, Where } from '@infrab4a/connect'
+
+import { CatalogSearchParams, CatalogSearchStrategy } from '../../../interfaces'
+import { CatalogHelpersService, CatalogRepositoryService } from '../services'
+
+import {
+  FindAndSortByMostRelevantParams,
+  SearchDefaultParams,
+  SearchWithMostRelevantParams,
+} from './types/strategy-params.type'
+
+@Injectable()
+export class CategorySearchStrategy implements CatalogSearchStrategy {
+  constructor(
+    private readonly repositoryService: CatalogRepositoryService,
+    private readonly helpersService: CatalogHelpersService,
+  ) {}
+
+  async search(
+    params: CatalogSearchParams,
+    shop: Shops,
+    optionsCache?: { cache?: RepositoryCacheOptions },
+  ): Promise<RepositoryFindResult<Product>> {
+    const { category, filters, limits, sort, mainGender } = params
+
+    if (!category) {
+      throw new Error('Category is required for CategorySearchStrategy')
+    }
+
+    const fields = this.helpersService.getFieldsHelper().getStandardFields()
+
+    if (category.isWishlist) {
+      return this.searchDefault({
+        category,
+        filters,
+        limits,
+        shop,
+        mainGender,
+        sort: sort === 'most-relevant' ? 'best-sellers' : sort,
+        optionsCache,
+        fields,
+      })
+    }
+
+    if (sort === 'most-relevant') {
+      return this.searchWithMostRelevant({
+        category,
+        filters,
+        limits,
+        shop,
+        mainGender,
+        optionsCache,
+        fields,
+      })
+    }
+
+    return this.searchDefault({
+      category,
+      filters,
+      limits,
+      shop,
+      mainGender,
+      sort,
+      optionsCache,
+      fields,
+    })
+  }
+
+  private async searchWithMostRelevant(params: SearchWithMostRelevantParams) {
+    const { category, filters, shop, optionsCache } = params
+    const mostRelevant = category.isWishlist ? [] : category.getMostRelevantByShop(shop)
+    const productsIds = await this.getProductIds(category, filters, optionsCache)
+
+    return this.findAndSortByMostRelevant({
+      mostRelevants: mostRelevant,
+      productIds: productsIds,
+      filters: params.filters,
+      limits: params.limits,
+      shop: params.shop,
+      mainGender: params.mainGender,
+      optionsCache: params.optionsCache,
+      fields: params.fields,
+    })
+  }
+
+  private async searchDefault(params: SearchDefaultParams) {
+    const { category, filters, limits, sort, optionsCache, fields } = params
+    const productCatalog = this.repositoryService.getProductCatalog()
+    const filterHelper = this.helpersService.getFilterHelper()
+    const sortHelper = this.helpersService.getSortHelper()
+
+    const repoParams = {
+      fields,
+      filters: {
+        ...(await productCatalog.categoryStructureAdapter.buildProductFilterByCategory(category)),
+        ...filterHelper.buildFilterQuery(filters || {}),
+      },
+      ...(sort ? { orderBy: sortHelper.buildSortQuery(sort) } : {}),
+      limits,
+      options: {
+        minimal: ['price'],
+        maximum: ['price'],
+        distinct: ['brand'],
+      },
+    }
+
+    return productCatalog.productCatalogRepository.findCatalog(repoParams, null, optionsCache)
+  }
+
+  private async getProductIds(category: any, filters: any, optionsCache: any): Promise<string[]> {
+    const productCatalog = this.repositoryService.getProductCatalog()
+    const filterHelper = this.helpersService.getFilterHelper()
+
+    return productCatalog.productCatalogRepository
+      .findCatalog(
+        {
+          fields: ['id'],
+          filters: {
+            ...(await productCatalog.categoryStructureAdapter.buildProductFilterByCategory(category)),
+            ...filterHelper.buildFilterQuery(filters || {}),
+          },
+        },
+        undefined,
+        optionsCache,
+      )
+      .then((products) => products.data.map((product) => product.id))
+  }
+
+  private async findAndSortByMostRelevant(
+    params: FindAndSortByMostRelevantParams,
+  ): Promise<RepositoryFindResult<Product>> {
+    const { mostRelevants, productIds, filters, shop, mainGender, optionsCache, fields, limits } = params
+    const productCatalog = this.repositoryService.getProductCatalog()
+    const filterHelper = this.helpersService.getFilterHelper()
+    const sortHelper = this.helpersService.getSortHelper()
+
+    const mostRelevantProductsIds = [...new Set(mostRelevants.concat(productIds))]
+    const totalResult = await productCatalog.productCatalogRepository.findCatalog(
+      {
+        fields,
+        filters: {
+          id: { operator: Where.IN, value: mostRelevantProductsIds },
+          ...filterHelper.buildFilterQuery(filters || {}),
+        },
+        orderBy: sortHelper.buildSortQuery('best-sellers'),
+        options: {
+          minimal: ['price'],
+          maximum: ['price'],
+          ...(isEmpty(filters?.brands) ? { distinct: ['brand'] } : {}),
+        },
+      },
+      mainGender || (shop === Shops.MENSMARKET ? 'male' : 'female'),
+      optionsCache,
+    )
+
+    return this.sortProductsByRelevance(totalResult, mostRelevants, limits)
+  }
+
+  private sortProductsByRelevance(totalResult: any, mostRelevants: string[], limits: any) {
+    const mostRelevantWithoutStock = totalResult.data.filter(
+      (product: any) => mostRelevants.includes(product.id) && product.stock.quantity <= 0,
+    )
+    const firstProducts = totalResult.data
+      .filter((product: any) => mostRelevants.includes(product.id) && product.stock.quantity > 0)
+      .sort((a: any, b: any) => mostRelevants.indexOf(a.id) - mostRelevants.indexOf(b.id))
+    const lastProducts = totalResult.data
+      .filter((product: any) => !mostRelevants.includes(product.id))
+      .concat(mostRelevantWithoutStock)
+    const categoryMostRelevants = firstProducts.concat(lastProducts)
+    const resultFinal = categoryMostRelevants.slice(limits.offset, limits.offset + limits.limit)
+
+    return {
+      data: resultFinal,
+      count: totalResult.count,
+      maximum: totalResult.maximum,
+      minimal: totalResult.minimal,
+      distinct: totalResult.distinct,
+    }
+  }
+}

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

@@ -0,0 +1,3 @@
+export * from './category-search.strategy'
+export * from './profile-search.strategy'
+export * from './term-search.strategy'

package/src/services/catalog/strategies/profile-search.strategy.ts

@@ -0,0 +1,51 @@
+import { Injectable } from '@angular/core'
+import { Product, RepositoryCacheOptions, RepositoryFindResult, Shops, Where } from '@infrab4a/connect'
+
+import { CatalogSearchParams, CatalogSearchStrategy } from '../../../interfaces'
+import { CatalogHelpersService, CatalogRepositoryService } from '../services'
+
+@Injectable()
+export class ProfileSearchStrategy implements CatalogSearchStrategy {
+  constructor(
+    private readonly repositoryService: CatalogRepositoryService,
+    private readonly helpersService: CatalogHelpersService,
+  ) {}
+
+  async search(
+    params: CatalogSearchParams,
+    shop: Shops,
+    optionsCache?: { cache?: RepositoryCacheOptions },
+  ): Promise<RepositoryFindResult<Product>> {
+    const { profile, filters, limits, sort, mainGender } = params
+
+    if (!profile) {
+      throw new Error('Profile is required for ProfileSearchStrategy')
+    }
+
+    const productCatalog = this.repositoryService.getProductCatalog()
+    const filterHelper = this.helpersService.getFilterHelper()
+    const sortHelper = this.helpersService.getSortHelper()
+    const fieldsHelper = this.helpersService.getFieldsHelper()
+
+    const repoParams = {
+      fields: fieldsHelper.getStandardFields(),
+      filters: {
+        tagsProfile: { operator: Where.LIKE, value: profile },
+        ...filterHelper.buildFilterQuery(filters || {}),
+      },
+      ...(sort ? { orderBy: sortHelper.buildSortQuery(sort) } : {}),
+      limits,
+      options: {
+        minimal: ['price'],
+        maximum: ['price'],
+        distinct: ['brand'],
+      },
+    }
+
+    return productCatalog.productCatalogRepository.findCatalog(
+      repoParams,
+      mainGender || (shop === Shops.MENSMARKET ? 'male' : 'female'),
+      optionsCache,
+    )
+  }
+}

package/src/services/catalog/strategies/term-search.strategy.ts

@@ -0,0 +1,163 @@
+import { Injectable } from '@angular/core'
+import {
+  isEmpty,
+  Product,
+  ProductSearch,
+  RepositoryCacheOptions,
+  RepositoryFindResult,
+  Shops,
+  Where,
+} from '@infrab4a/connect'
+
+import { CatalogSearchParams, CatalogSearchStrategy } from '../../../interfaces'
+import { CatalogHelpersService, CatalogRepositoryService } from '../services'
+
+import {
+  SortByTermRelevanceParams,
+  TermSearchDefaultParams,
+  TermSearchMostRelevantParams,
+} from './types/strategy-params.type'
+
+@Injectable()
+export class TermSearchStrategy implements CatalogSearchStrategy {
+  private productsByTerm: Record<string, string[]> = {}
+
+  constructor(
+    private readonly repositoryService: CatalogRepositoryService,
+    private readonly helpersService: CatalogHelpersService,
+  ) {}
+
+  async search(
+    params: CatalogSearchParams,
+    shop: Shops,
+    _optionsCache?: { cache?: RepositoryCacheOptions },
+  ): Promise<RepositoryFindResult<Product>> {
+    const { term, filters, limits, sort, mainGender } = params
+
+    if (!term) {
+      throw new Error('Term is required for TermSearchStrategy')
+    }
+
+    const productIds = await this.findCatalogIdsBySearch(term, shop)
+
+    if (sort === 'most-relevant') {
+      return this.searchWithMostRelevant({
+        productIds,
+        filters,
+        limits,
+        shop,
+        mainGender,
+      })
+    }
+
+    return this.searchDefault({
+      productIds,
+      filters,
+      limits,
+      shop,
+      mainGender,
+      sort,
+      fields: this.helpersService.getFieldsHelper().getStandardFields(),
+    })
+  }
+
+  private async searchWithMostRelevant(params: TermSearchMostRelevantParams): Promise<RepositoryFindResult<Product>> {
+    const { productIds, filters, shop, mainGender } = params
+    const productCatalog = this.repositoryService.getProductCatalog()
+    const filterHelper = this.helpersService.getFilterHelper()
+
+    const totalResult = await productCatalog.productCatalogRepository.findCatalog(
+      {
+        fields: ['id', 'stock', 'gender'],
+        filters: {
+          id: { operator: Where.IN, value: productIds },
+          published: { operator: Where.EQUALS, value: true },
+          ...filterHelper.buildFilterQuery(filters || {}),
+        },
+        options: {
+          minimal: ['price'],
+          maximum: ['price'],
+          ...(isEmpty(filters?.brands) ? { distinct: ['brand'] } : {}),
+        },
+      },
+      // mainGender || (shop === Shops.MENSMARKET ? 'male' : 'female'),
+    )
+
+    return this.sortByTermRelevance({
+      productIds,
+      totalResult,
+      limits: params.limits,
+      filters,
+      fieldsHelper: this.helpersService.getFieldsHelper(),
+    })
+  }
+
+  private async searchDefault(params: TermSearchDefaultParams): Promise<RepositoryFindResult<Product>> {
+    const { productIds, filters, limits, sort, shop, mainGender, fields } = params
+    const productCatalog = this.repositoryService.getProductCatalog()
+    const filterHelper = this.helpersService.getFilterHelper()
+    const sortHelper = this.helpersService.getSortHelper()
+
+    return productCatalog.productCatalogRepository.findCatalog(
+      {
+        fields,
+        filters: {
+          id: { operator: Where.IN, value: productIds },
+          published: { operator: Where.EQUALS, value: true },
+          ...filterHelper.buildFilterQuery(filters || {}),
+        },
+        limits,
+        ...(sort ? { orderBy: sortHelper.buildSortQuery(sort) } : {}),
+        options: {
+          minimal: ['price'],
+          maximum: ['price'],
+          distinct: ['brand'],
+        },
+      },
+      // mainGender || (shop === Shops.MENSMARKET ? 'male' : 'female'),
+    )
+  }
+
+  private sortByTermRelevance(params: SortByTermRelevanceParams) {
+    const { productIds, totalResult, limits, filters, fieldsHelper } = params
+    // const defaultGender = filters?.gender?.at(0) || 'male'
+    const stockData = totalResult.data.filter((product: any) => product.stock.quantity > 0)
+    const stockOut = totalResult.data.filter((product: any) => product.stock.quantity <= 0)
+    const productIdsStock = productIds.filter((product) => stockData.some((result: any) => result.id === product))
+    const productIdsStockOut = productIds.filter((product) => stockOut.some((result: any) => result.id === product))
+    const limitedProductId = productIdsStock
+      .concat(productIdsStockOut)
+      .slice(limits.offset, limits.offset + limits.limit)
+
+    return this.getDetailedProducts(limitedProductId, totalResult, fieldsHelper)
+  }
+
+  private async getDetailedProducts(orderedId: string[], totalResult: any, fieldsHelper: any) {
+    const productCatalog = this.repositoryService.getProductCatalog()
+    const fields = fieldsHelper.getStandardFields()
+    const productResult = await productCatalog.productCatalogRepository.findCatalog({
+      filters: {
+        id: { operator: Where.IN, value: orderedId },
+      },
+      fields,
+    })
+
+    return {
+      data: orderedId.map((id) => productResult.data.find((product) => product.id === id)).filter(Boolean),
+      count: totalResult.count,
+      maximum: totalResult.maximum,
+      minimal: totalResult.minimal,
+      distinct: totalResult.distinct,
+    }
+  }
+
+  private async findCatalogIdsBySearch(term: string, shop: Shops): Promise<string[]> {
+    if (this.productsByTerm[term]) return this.productsByTerm[term]
+
+    const productServices = this.repositoryService.getProductServices()
+
+    return (this.productsByTerm[term] = await productServices.productSearch
+      .search<ProductSearch>(term, 999, shop === Shops.GLAMSHOP ? 'female' : 'male')
+      .then((products) => [...new Set(products.map((product) => product.id))]))
+  }
+}

package/src/services/catalog/strategies/types/strategy-params.type.ts

@@ -0,0 +1,59 @@
+import { RepositoryCacheOptions, Shops } from '@infrab4a/connect'
+
+export type SearchWithMostRelevantParams = {
+  category: any
+  filters: any
+  limits: any
+  shop: Shops
+  mainGender: any
+  optionsCache: { cache?: RepositoryCacheOptions } | undefined
+  fields: any
+}
+
+export type SearchDefaultParams = {
+  category: any
+  filters: any
+  limits: any
+  shop: Shops
+  mainGender: any
+  sort: any
+  optionsCache: { cache?: RepositoryCacheOptions } | undefined
+  fields: any
+}
+
+export type FindAndSortByMostRelevantParams = {
+  mostRelevants: string[]
+  productIds: string[]
+  filters: any
+  limits: any
+  shop: Shops
+  mainGender: any
+  optionsCache: { cache?: RepositoryCacheOptions } | undefined
+  fields: any
+}
+
+export type TermSearchMostRelevantParams = {
+  productIds: string[]
+  filters: any
+  limits: any
+  mainGender: any
+  shop: Shops
+}
+
+export type TermSearchDefaultParams = {
+  productIds: string[]
+  filters: any
+  limits: any
+  mainGender: any
+  shop: Shops
+  fields: any
+  sort?: any
+}
+
+export type SortByTermRelevanceParams = {
+  productIds: string[]
+  totalResult: any
+  limits: any
+  filters: any
+  fieldsHelper: any
+}

package/src/services/catalog/types/fetch-products-options.type.ts

@@ -0,0 +1,10 @@
+import { ProductGender } from '@infrab4a/connect'
+
+import { ProductSort } from './product-sort.type'
+
+export type FetchProductsOptions = {
+  page?: number
+  perPage?: number
+  sort?: ProductSort
+  mainGender?: ProductGender
+}

package/src/services/catalog/types/fetch-products-params.type.ts

@@ -0,0 +1,27 @@
+import { Category } from '@infrab4a/connect'
+
+import { CatalogFilters } from '../../../interfaces'
+
+import { FetchProductsOptions } from './fetch-products-options.type'
+
+export type FetchProductsMainParams<T extends Category> = {
+  category?: T
+  profile?: string[]
+  term?: string
+}
+
+export type FetchProductsParams<T extends Category> = FetchProductsOptions &
+  (
+    | {
+        category: FetchProductsMainParams<T>['category']
+        filters?: CatalogFilters & { customOptions?: never }
+      }
+    | {
+        profile: FetchProductsMainParams<T>['profile']
+        filters?: CatalogFilters & { customOptions?: never; tags?: never }
+      }
+    | {
+        term: FetchProductsMainParams<T>['term']
+        filters?: CatalogFilters & { customOptions?: never }
+      }
+  )

package/src/services/catalog/types/fetch-products-response.type.ts

@@ -0,0 +1,11 @@
+import { Product } from '@infrab4a/connect'
+
+export type FetchProductsResponse = {
+  products: { data: Product[]; total: number }
+  pages: number
+  prices: {
+    price: { min: number; max: number }
+    subscriberPrice: { min: number; max: number }
+  }
+  brands?: string[]
+}

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

@@ -0,0 +1,5 @@
+export * from './fetch-products-options.type'
+export * from './fetch-products-params.type'
+export * from './fetch-products-response.type'
+export * from './method-params.type'
+export * from './product-sort.type'

package/src/services/catalog/types/method-params.type.ts

@@ -0,0 +1,21 @@
+import { Category, Product, Shops } from '@infrab4a/connect'
+
+import { CatalogSearchParams } from '../../../interfaces'
+
+import { FetchProductsParams } from './fetch-products-params.type'
+
+export type StockNotificationParams = {
+  shop: Shops
+  productId: string
+  name: string
+  email: string
+}
+
+export type BuildResponseParams<T extends Category = Category> = {
+  data: Product[]
+  total: number
+  maximum: any
+  minimal: any
+  searchParams: CatalogSearchParams
+  options: FetchProductsParams<T>
+}

package/src/services/catalog/types/product-sort.type.ts

@@ -0,0 +1,3 @@
+import { ProductSorts } from '../enums'
+
+export type ProductSort = `${ProductSorts}`