@infrab4a/connect-angular 5.8.19 → 5.8.21-beta.0

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

@@ -0,0 +1,214 @@
+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,
+  }
+
+  const daysAgo = (days: number): Date => new Date(Date.now() - days * 24 * 60 * 60 * 1000)
+
+  const buildProduct = (overrides: Partial<Product> & { id: string }): Product =>
+    ({
+      stock: { quantity: 10 },
+      shoppingCount: 0,
+      createdAt: daysAgo(60),
+      ...overrides,
+    }) as Product
+
+  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)
+  })
+
+  it('should keep wishlist most-relevant as best-sellers without pins/Novo block', 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)
+    expect(findCatalog.calls.mostRecent().args[0].orderBy.shoppingCount).toBe('desc')
+  })
+
+  describe('most-relevant in-memory order', () => {
+    const setupMostRelevant = (products: Product[], pinIds: string[]) => {
+      const category = {
+        id: '20',
+        isWishlist: false,
+        getMostRelevantByShop: () => pinIds,
+      } as unknown as Category
+
+      findCatalog.and.callFake(async (params: any) => {
+        if (params.fields?.length === 1 && params.fields[0] === 'id') {
+          return { data: products.map((p) => ({ id: p.id })), count: products.length }
+        }
+
+        return { data: products, count: products.length }
+      })
+
+      return category
+    }
+
+    it('should keep in-stock pin first when most-relevant', async () => {
+      const products = [
+        buildProduct({ id: 'C', shoppingCount: 100, createdAt: daysAgo(60) }),
+        buildProduct({ id: 'P', shoppingCount: 1, createdAt: daysAgo(60) }),
+      ]
+      const category = setupMostRelevant(products, ['P'])
+
+      const result = await strategy.search({ category, filters: {}, limits, sort: 'most-relevant' }, shop)
+
+      expect(result.data.map((p) => p.id)).toEqual(['P', 'C'])
+    })
+
+    it('should place in-stock Novo after pins ordered by createdAt desc', async () => {
+      const products = [
+        buildProduct({ id: 'C', shoppingCount: 100, createdAt: daysAgo(60) }),
+        buildProduct({ id: 'B', shoppingCount: 5, createdAt: daysAgo(20) }),
+        buildProduct({ id: 'A', shoppingCount: 5, createdAt: daysAgo(5) }),
+        buildProduct({ id: 'P', shoppingCount: 1, createdAt: daysAgo(60) }),
+      ]
+      const category = setupMostRelevant(products, ['P'])
+
+      const result = await strategy.search({ category, filters: {}, limits, sort: 'most-relevant' }, shop)
+
+      expect(result.data.map((p) => p.id)).toEqual(['P', 'A', 'B', 'C'])
+    })
+
+    it('should not duplicate a pinned Novo', async () => {
+      const products = [
+        buildProduct({ id: 'C', shoppingCount: 50, createdAt: daysAgo(60) }),
+        buildProduct({ id: 'P', shoppingCount: 1, createdAt: daysAgo(3) }),
+      ]
+      const category = setupMostRelevant(products, ['P'])
+
+      const result = await strategy.search({ category, filters: {}, limits, sort: 'most-relevant' }, shop)
+
+      expect(result.data.map((p) => p.id)).toEqual(['P', 'C'])
+      expect(result.data.filter((p) => p.id === 'P').length).toBe(1)
+    })
+
+    it('should keep age 0 and 30 days in Novo block and exclude 31 days', async () => {
+      const products = [
+        buildProduct({ id: 'old', shoppingCount: 80, createdAt: daysAgo(31) }),
+        buildProduct({ id: 'edge', shoppingCount: 5, createdAt: daysAgo(30) }),
+        buildProduct({ id: 'fresh', shoppingCount: 5, createdAt: daysAgo(0) }),
+      ]
+      const category = setupMostRelevant(products, [])
+
+      const result = await strategy.search({ category, filters: {}, limits, sort: 'most-relevant' }, shop)
+
+      expect(result.data.map((p) => p.id)).toEqual(['fresh', 'edge', 'old'])
+    })
+
+    it('should not treat invalid or future createdAt as Novo', async () => {
+      const products = [
+        buildProduct({ id: 'best', shoppingCount: 90, createdAt: daysAgo(60) }),
+        buildProduct({ id: 'invalid', shoppingCount: 5, createdAt: 'not-a-date' as any }),
+        buildProduct({ id: 'future', shoppingCount: 5, createdAt: new Date(Date.now() + 86400000) }),
+      ]
+      const category = setupMostRelevant(products, [])
+
+      const result = await strategy.search({ category, filters: {}, limits, sort: 'most-relevant' }, shop)
+
+      expect(result.data.map((p) => p.id)).toEqual(['best', 'invalid', 'future'])
+    })
+
+    it('should not boost OOS Novo above in-stock bestsellers', async () => {
+      const products = [
+        buildProduct({ id: 'best', shoppingCount: 100, createdAt: daysAgo(60), stock: { quantity: 5 } as any }),
+        buildProduct({
+          id: 'oos-novo',
+          shoppingCount: 1,
+          createdAt: daysAgo(2),
+          stock: { quantity: 0 } as any,
+        }),
+      ]
+      const category = setupMostRelevant(products, [])
+
+      const result = await strategy.search({ category, filters: {}, limits, sort: 'most-relevant' }, shop)
+
+      expect(result.data.map((p) => p.id)).toEqual(['best', 'oos-novo'])
+    })
+  })
+})

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

@@ -0,0 +1,207 @@
+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 nonPinnedProducts = totalResult.data.filter((product: any) => !mostRelevants.includes(product.id))
+    const novoProducts = nonPinnedProducts
+      .filter((product: any) => product.stock?.quantity > 0 && this.isCreatedWithinLastDays(product.createdAt, 30))
+      .sort((a: any, b: any) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime())
+    const restProducts = nonPinnedProducts.filter(
+      (product: any) => !(product.stock?.quantity > 0 && this.isCreatedWithinLastDays(product.createdAt, 30)),
+    )
+
+    const lastProducts = novoProducts.concat(restProducts).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,
+    }
+  }
+
+  private isCreatedWithinLastDays(createdAt: string | Date | undefined, days: number): boolean {
+    if (!createdAt || days <= 0) {
+      return false
+    }
+
+    const createdDate = createdAt instanceof Date ? createdAt : new Date(createdAt)
+    if (Number.isNaN(createdDate.getTime())) {
+      return false
+    }
+
+    const diffMs = Date.now() - createdDate.getTime()
+    if (diffMs < 0) {
+      return false
+    }
+
+    const diffDays = diffMs / (1000 * 60 * 60 * 24)
+    return diffDays <= days
+  }
+}

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
+}