Fix default zero facets on placeholdersearch and routing

src/adapter/search-request-adapter/search-params-adapter.ts

@@ -14,7 +14,7 @@ import { adaptFilters } from './filter-adapter'
  *
  * @returns {MeiliSearchParams}
  */
-function MeiliParamsCreator(searchContext: SearchContext) {
+export function MeiliParamsCreator(searchContext: SearchContext) {
   const meiliSearchParams: Record<string, any> = {}
   const {
     facets,

src/adapter/search-request-adapter/search-resolver.ts

@@ -7,20 +7,13 @@ import {
 } from '../../types'
 import { addMissingFacets, extractFacets } from './filters'
 
-const emptySearch: MeiliSearchResponse<Record<string, any>> = {
-  hits: [],
-  query: '',
-  facetDistribution: {},
-  limit: 0,
-  offset: 0,
-  estimatedTotalHits: 0,
-  processingTimeMs: 0,
-}
-
 /**
  * @param  {ResponseCacher} cache
  */
-export function SearchResolver(cache: SearchCacheInterface) {
+export function SearchResolver(
+  client: MeiliSearch,
+  cache: SearchCacheInterface
+) {
   return {
     /**
      * @param  {SearchContext} searchContext
@@ -30,17 +23,10 @@ export function SearchResolver(cache: SearchCacheInterface) {
      */
     searchResponse: async function (
       searchContext: SearchContext,
-      searchParams: MeiliSearchParams,
-      client: MeiliSearch
+      searchParams: MeiliSearchParams
     ): Promise<MeiliSearchResponse<Record<string, any>>> {
       const { placeholderSearch, query } = searchContext
 
-      // query can be: empty string, undefined or null
-      // all of them are falsy's
-      if (!placeholderSearch && !query) {
-        return emptySearch
-      }
-
       const { pagination } = searchContext
 
       // In case we are in a `finitePagination`, only one big request is made
@@ -74,6 +60,12 @@ export function SearchResolver(cache: SearchCacheInterface) {
         searchResponse.facetDistribution
       )
 
+      // query can be: empty string, undefined or null
+      // all of them are falsy's
+      if (!placeholderSearch && !query) {
+        searchResponse.hits = []
+        searchResponse.estimatedTotalHits = 0
+      }
       // Cache response
       cache.setEntry<MeiliSearchResponse>(key, searchResponse)
       return searchResponse

src/cache/first-facets-distribution.ts

@@ -1,14 +1,20 @@
-import { FacetDistribution } from '../types'
+import { FacetDistribution, SearchContext } from '../types'
+import { MeiliParamsCreator } from '../adapter'
 
-export function cacheFirstFacetDistribution(
-  defaultFacetDistribution: FacetDistribution,
-  searchResponse: any
-): FacetDistribution {
-  if (
-    searchResponse.query === '' &&
-    Object.keys(defaultFacetDistribution).length === 0
-  ) {
-    return searchResponse.facetDistribution
-  }
-  return defaultFacetDistribution
+export async function cacheFirstFacetDistribution(
+  searchResolver: any,
+  searchContext: SearchContext
+): Promise<FacetDistribution> {
+  const meilisearchParams = MeiliParamsCreator(searchContext)
+  meilisearchParams.addFacets()
+  meilisearchParams.addAttributesToRetrieve()
+
+  // Search response from Meilisearch
+  const searchResponse = await searchResolver.searchResponse(
+    // placeholdersearch true to ensure a request is made
+    // query set to empty to ensure default facetdistributionap
+    { ...searchContext, placeholderSearch: true, query: '' },
+    meilisearchParams.getParams()
+  )
+  return searchResponse.facetDistribution || {}
 }

src/client/instant-meilisearch-client.ts

@@ -28,11 +28,6 @@ export function instantMeiliSearch(
   apiKey = '',
   instantMeiliSearchOptions: InstantMeiliSearchOptions = {}
 ): InstantMeiliSearchInstance {
-  const searchCache = SearchCache()
-  // create search resolver with included cache
-  const searchResolver = SearchResolver(searchCache)
-  // paginationTotalHits can be 0 as it is a valid number
-  let defaultFacetDistribution: any = {}
   const clientAgents = constructClientAgents(
     instantMeiliSearchOptions.clientAgents
   )
@@ -43,6 +38,12 @@ export function instantMeiliSearch(
     clientAgents,
   })
 
+  const searchCache = SearchCache()
+  // create search resolver with included cache
+  const searchResolver = SearchResolver(meilisearchClient, searchCache)
+
+  let defaultFacetDistribution: any
+
   return {
     clearCache: () => searchCache.clearCache(),
     /**
@@ -63,26 +64,29 @@ export function instantMeiliSearch(
         // Adapt search request to Meilisearch compliant search request
         const adaptedSearchRequest = adaptSearchParams(searchContext)
 
-        // Search response from Meilisearch
-        const searchResponse = await searchResolver.searchResponse(
-          searchContext,
-          adaptedSearchRequest,
-          meilisearchClient
-        )
-
         // Cache first facets distribution of the instantMeilisearch instance
         // Needed to add in the facetDistribution the fields that were not returned
         // When the user sets `keepZeroFacets` to true.
-        defaultFacetDistribution = cacheFirstFacetDistribution(
-          defaultFacetDistribution,
-          searchResponse
+        if (defaultFacetDistribution === undefined) {
+          defaultFacetDistribution = await cacheFirstFacetDistribution(
+            searchResolver,
+            searchContext
+          )
+          searchContext.defaultFacetDistribution = defaultFacetDistribution
+        }
+
+        // Search response from Meilisearch
+        const searchResponse = await searchResolver.searchResponse(
+          searchContext,
+          adaptedSearchRequest
         )
 
         // Adapt the Meilisearch responsne to a compliant instantsearch.js response
         const adaptedSearchResponse = adaptSearchResponse<T>(
           searchResponse,
           searchContext
         )
+
         return adaptedSearchResponse
       } catch (e: any) {
         console.error(e)

src/contexts/search-context.ts

@@ -33,7 +33,7 @@ export function createSearchContext(
     sort: sortByArray.join(':') || '',
     indexUid,
     pagination,
-    defaultFacetDistribution,
+    defaultFacetDistribution: defaultFacetDistribution || {},
     placeholderSearch: options.placeholderSearch !== false, // true by default
     keepZeroFacets: !!options.keepZeroFacets, // false by default
     finitePagination: !!options.finitePagination, // false by default

tests/assets/utils.ts

@@ -1,6 +1,9 @@
 import { instantMeiliSearch } from '../../src'
 import { MeiliSearch } from 'meilisearch'
 
+const HOST = 'http://localhost:7700'
+const API_KEY = 'masterKey'
+
 const dataset = [
   {
     id: 2,
@@ -225,8 +228,8 @@ const wrongSearchClient = instantMeiliSearch(
   'masterKey'
 )
 const meilisearchClient = new MeiliSearch({
-  host: 'http://localhost:7700',
-  apiKey: 'masterKey',
+  host: HOST,
+  apiKey: API_KEY,
 })
 
 export {
@@ -235,4 +238,6 @@ export {
   wrongSearchClient,
   geoDataset,
   meilisearchClient,
+  HOST,
+  API_KEY,
 }

tests/first-facets-distribution.tests.ts

@@ -0,0 +1,148 @@
+import { dataset, meilisearchClient, HOST, API_KEY } from './assets/utils'
+import { instantMeiliSearch } from '../src'
+
+describe('Firt facet distribution', () => {
+  beforeAll(async () => {
+    const deleteTask = await meilisearchClient.deleteIndex('movies')
+    await meilisearchClient.waitForTask(deleteTask.taskUid)
+    await meilisearchClient
+      .index('movies')
+      .updateFilterableAttributes(['genres'])
+    const documentsTask = await meilisearchClient
+      .index('movies')
+      .addDocuments(dataset)
+    await meilisearchClient.index('movies').waitForTask(documentsTask.taskUid)
+  })
+
+  test('creation of facet distribution without facets', async () => {
+    const searchClient = instantMeiliSearch(HOST, API_KEY)
+    const response = await searchClient.search([
+      {
+        indexName: 'movies',
+        params: {
+          facets: [],
+          query: '',
+        },
+      },
+    ])
+    expect(response.results[0].facets).toEqual({})
+  })
+
+  test('creation of facet distribution without facets and with keepZeroFacets to true', async () => {
+    const searchClient = instantMeiliSearch(HOST, API_KEY, {
+      keepZeroFacets: false,
+    })
+    const response = await searchClient.search([
+      {
+        indexName: 'movies',
+        params: {
+          facets: [],
+          query: '',
+        },
+      },
+    ])
+    expect(response.results[0].facets).toEqual({})
+  })
+
+  test('creation of facet distribution with facets', async () => {
+    const searchClient = instantMeiliSearch(HOST, API_KEY)
+    const response = await searchClient.search([
+      {
+        indexName: 'movies',
+        params: {
+          facets: ['genres'],
+          query: '',
+        },
+      },
+    ])
+    expect(response.results[0].facets).toEqual({
+      genres: {
+        Action: 3,
+        Adventure: 1,
+        Animation: 1,
+        Comedy: 2,
+        Crime: 4,
+        Drama: 1,
+        'Science Fiction': 2,
+        Thriller: 1,
+      },
+    })
+  })
+
+  test('creation of facet distribution with facets and keepZeroFacets to true', async () => {
+    const searchClient = instantMeiliSearch(HOST, API_KEY, {
+      keepZeroFacets: true,
+    })
+    const response = await searchClient.search([
+      {
+        indexName: 'movies',
+        params: {
+          facets: ['genres'],
+          query: '',
+        },
+      },
+    ])
+    expect(response.results[0].facets).toEqual({
+      genres: {
+        Action: 3,
+        Adventure: 1,
+        Animation: 1,
+        Comedy: 2,
+        Crime: 4,
+        Drama: 1,
+        'Science Fiction': 2,
+        Thriller: 1,
+      },
+    })
+
+    const response2 = await searchClient.search([
+      {
+        indexName: 'movies',
+        params: {
+          facets: ['genres'],
+          query: 'no results',
+        },
+      },
+    ])
+
+    expect(response2.results[0].facets).toEqual({
+      genres: {
+        Action: 0,
+        Adventure: 0,
+        Animation: 0,
+        Comedy: 0,
+        Crime: 0,
+        Drama: 0,
+        'Science Fiction': 0,
+        Thriller: 0,
+      },
+    })
+  })
+
+  test('creation of facet distribution with facets, keepZeroFacets to true, and query', async () => {
+    const searchClient = instantMeiliSearch(HOST, API_KEY, {
+      keepZeroFacets: true,
+    })
+    const response = await searchClient.search([
+      {
+        indexName: 'movies',
+        params: {
+          facets: ['genres'],
+          query: 'no results',
+        },
+      },
+    ])
+    expect(response.results[0].facets).toEqual({
+      genres: {
+        Action: 0,
+        Adventure: 0,
+        Animation: 0,
+        Comedy: 0,
+        Crime: 0,
+        Drama: 0,
+        'Science Fiction': 0,
+        Thriller: 0,
+      },
+    })
+  })
+})

tests/search-resolver.tests.ts

@@ -51,7 +51,7 @@ describe('Pagination browser test', () => {
       apiKey: '',
       clientAgents: [`Meilisearch instant-meilisearch (v${PACKAGE_VERSION})`],
     })
-    expect(mockedSearch).toHaveBeenCalledTimes(1)
+    expect(mockedSearch).toHaveBeenCalledTimes(2)
   })
 
   test('two different search parameters', async () => {
@@ -77,7 +77,7 @@ describe('Pagination browser test', () => {
       apiKey: '',
       clientAgents: [`Meilisearch instant-meilisearch (v${PACKAGE_VERSION})`],
     })
-    expect(mockedSearch).toHaveBeenCalledTimes(2)
+    expect(mockedSearch).toHaveBeenCalledTimes(3)
   })
 
   test('two identical and one different search parameters', async () => {
@@ -104,7 +104,7 @@ describe('Pagination browser test', () => {
       apiKey: '',
       clientAgents: [`Meilisearch instant-meilisearch (v${PACKAGE_VERSION})`],
     })
-    expect(mockedSearch).toHaveBeenCalledTimes(2)
+    expect(mockedSearch).toHaveBeenCalledTimes(3)
   })
 
   test('two same and two different search parameter', async () => {
@@ -132,6 +132,6 @@ describe('Pagination browser test', () => {
       apiKey: '',
       clientAgents: [`Meilisearch instant-meilisearch (v${PACKAGE_VERSION})`],
     })
-    expect(mockedSearch).toHaveBeenCalledTimes(2)
+    expect(mockedSearch).toHaveBeenCalledTimes(3)
   })
 })