Add multi index and disjunctive facet search

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

@@ -76,8 +76,10 @@ export function MeiliParamsCreator(searchContext: SearchContext) {
       return meiliSearchParams
     },
     addFacets() {
-      if (facets?.length) {
+      if (Array.isArray(facets)) {
         meiliSearchParams.facets = facets
+      } else if (typeof facets === 'string') {
+        meiliSearchParams.facets = [facets]
       }
     },
     addAttributesToCrop() {

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

@@ -39,18 +39,19 @@ export function SearchResolver(
       // Check if specific request is already cached with its associated search response.
       if (cachedResponse) return cachedResponse
 
-      const cachedFacets = extractFacets(searchContext, searchParams)
-
       // Make search request
       const searchResponse = await client
         .index(searchContext.indexUid)
         .search(searchContext.query, searchParams)
 
-      // Add missing facets back into facetDistribution
-      searchResponse.facetDistribution = addMissingFacets(
-        cachedFacets,
-        searchResponse.facetDistribution
-      )
+      if (searchContext.keepZeroFacets) {
+        const cachedFacets = extractFacets(searchContext, searchParams)
+        // Add missing facets back into facetDistribution
+        searchResponse.facetDistribution = addMissingFacets(
+          cachedFacets,
+          searchResponse.facetDistribution
+        )
+      }
 
       // query can be: empty string, undefined or null
       // all of them are falsy's

src/client/instant-meilisearch-client.ts

@@ -67,40 +67,48 @@ export function instantMeiliSearch(
       instantSearchRequests: readonly AlgoliaMultipleQueriesQuery[]
     ): Promise<{ results: Array<AlgoliaSearchResponse<T>> }> {
       try {
-        const searchRequest = instantSearchRequests[0]
-        const searchContext: SearchContext = createSearchContext(
-          searchRequest,
-          instantMeiliSearchOptions,
-          defaultFacetDistribution
-        )
+        const searchResponses: { results: Array<AlgoliaSearchResponse<T>> } = {
+          results: [],
+        }
 
-        // Adapt search request to Meilisearch compliant search request
-        const adaptedSearchRequest = adaptSearchParams(searchContext)
+        const requests = instantSearchRequests
+        for (const searchRequest of requests) {
+          const searchContext: SearchContext = createSearchContext(
+            searchRequest,
+            instantMeiliSearchOptions,
+            defaultFacetDistribution
+          )
 
-        // 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.
-        if (defaultFacetDistribution === undefined) {
-          defaultFacetDistribution = await cacheFirstFacetDistribution(
-            searchResolver,
-            searchContext
+          const adaptedSearchRequest = adaptSearchParams(searchContext)
+
+
+          // 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.
+          if (defaultFacetDistribution === undefined) {
+            defaultFacetDistribution = await cacheFirstFacetDistribution(
+              searchResolver,
+              searchContext
+            )
+            searchContext.defaultFacetDistribution = defaultFacetDistribution
+          }
+
+          // Search response from Meilisearch
+          const searchResponse = await searchResolver.searchResponse(
+            searchContext,
+            adaptedSearchRequest
           )
-          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
+          )
 
-        // Adapt the Meilisearch responsne to a compliant instantsearch.js response
-        const adaptedSearchResponse = adaptSearchResponse<T>(
-          searchResponse,
-          searchContext
-        )
+          searchResponses.results.push(adaptedSearchResponse.results[0])
+        }
 
-        return adaptedSearchResponse
+        return searchResponses
       } catch (e: any) {
         console.error(e)
         throw new Error(e)

tests/multi-index-search.tests.ts

@@ -0,0 +1,172 @@
+import { instantMeiliSearch } from '../src'
+import { Movies, meilisearchClient } from './assets/utils'
+import movies from './assets/movies.json'
+import games from './assets/games.json'
+
+describe('Multi-index search test', () => {
+  beforeAll(async () => {
+    const moviesIndex = meilisearchClient.index('movies')
+    const gamesIndex = meilisearchClient.index('games')
+
+    await moviesIndex.delete()
+    await gamesIndex.delete()
+
+    await moviesIndex.updateSettings({
+      filterableAttributes: ['genres', 'color', 'platforms'],
+    })
+    await gamesIndex.updateSettings({
+      filterableAttributes: ['genres', 'color', 'platforms'],
+    })
+
+    await moviesIndex.addDocuments(movies)
+    const response = await gamesIndex.addDocuments(games)
+
+    await meilisearchClient.waitForTask(response.taskUid)
+  })
+
+  test('searching on two indexes', async () => {
+    const customClient = instantMeiliSearch(
+      'http://localhost:7700',
+      'masterKey'
+    )
+
+    const response = await customClient.search<Movies>([
+      {
+        indexName: 'movies',
+        params: {
+          query: 'c',
+        },
+      },
+      {
+        indexName: 'games',
+        params: {
+          query: 'c',
+        },
+      },
+    ])
+
+    const movieHits = response.results[0].hits
+    const gameHits = response.results[1].hits
+
+    expect(movieHits.length).toBe(1)
+    expect(gameHits.length).toBe(14)
+  })
+
+  test('searching on two indexes with scroll pagination', async () => {
+    const customClient = instantMeiliSearch(
+      'http://localhost:7700',
+      'masterKey'
+    )
+
+    const response = await customClient.search<Movies>([
+      {
+        indexName: 'movies',
+        params: {
+          hitsPerPage: 1,
+          page: 1,
+        },
+      },
+      {
+        indexName: 'games',
+        params: {
+          hitsPerPage: 1,
+          page: 1,
+        },
+      },
+    ])
+
+    const movies = response.results[0]
+    const games = response.results[1]
+
+    expect(movies.hits.length).toBe(1)
+    expect(movies.page).toBe(1)
+    expect(movies.nbPages).toBe(3)
+
+    expect(games.hits.length).toBe(1)
+    expect(games.page).toBe(1)
+    expect(games.nbPages).toBe(3)
+  })
+
+  test('searching on two indexes with page selection pagination', async () => {
+    const customClient = instantMeiliSearch(
+      'http://localhost:7700',
+      'masterKey',
+      {
+        finitePagination: true,
+      }
+    )
+
+    const response = await customClient.search<Movies>([
+      {
+        indexName: 'movies',
+        params: {
+          hitsPerPage: 1,
+          page: 1,
+        },
+      },
+      {
+        indexName: 'games',
+        params: {
+          hitsPerPage: 1,
+          page: 1,
+        },
+      },
+    ])
+
+    const movies = response.results[0]
+    const games = response.results[1]
+
+    expect(movies.hits.length).toBe(1)
+    expect(movies.page).toBe(1)
+    expect(movies.nbPages).toBe(6)
+
+    expect(games.hits.length).toBe(1)
+    expect(games.page).toBe(1)
+    expect(games.nbPages).toBe(15)
+  })
+
+  test('searching on two indexes with no placeholder search', async () => {
+    const customClient = instantMeiliSearch(
+      'http://localhost:7700',
+      'masterKey',
+      {
+        placeholderSearch: false,
+      }
+    )
+
+    const emptyResponse = await customClient.search<Movies>([
+      {
+        indexName: 'movies',
+      },
+      {
+        indexName: 'games',
+      },
+    ])
+
+    const emptyMovies = emptyResponse.results[0]
+    const emptyGames = emptyResponse.results[1]
+
+    expect(emptyMovies.hits.length).toBe(0)
+    expect(emptyGames.hits.length).toBe(0)
+
+    const response = await customClient.search<Movies>([
+      {
+        indexName: 'movies',
+        params: {
+          query: 'a',
+        },
+      },
+      {
+        indexName: 'games',
+        params: {
+          query: 'a',
+        },
+      },
+    ])
+    const movies = response.results[0]
+    const games = response.results[1]
+
+    expect(movies.hits.length).toBe(4)
+    expect(games.hits.length).toBe(15)
+  })
+})

tsconfig.test.json

@@ -2,6 +2,7 @@
   "extends": "./tsconfig.json",
   "compilerOptions": {
     "suppressImplicitAnyIndexErrors": true,
+    "resolveJsonModule": true
   },
   "include": [
     "./**/*"