feature: handle per index meilisearch params (#1364)

* feat: handle per index meilisearch params

* fix: typescript error

* test: make sure adding an index properly overrides base meilisearchParams

* test: override client meilisearchParams in context

* lint: remove unused import

* docs: update README with example for indexOverrides

* feat: make facets and filters overridable

* override filters even when instantsearch filters are empty

* allow overriding sorting

* lint

* Merge existing override params when adding new with setMeilisearchParams

---------

Co-authored-by: Strift <lau.cazanove@gmail.com>

Author: 8byr0

packages/instant-meilisearch/README.md

@@ -296,7 +296,28 @@ instantMeiliSearch(
   }
 )
 ```
+When using multi search, meilisearchParams can be overriden for specific indexes :
 
+```js
+instantMeiliSearch(
+  // ...
+  {
+    meiliSearchParams: {
+      // All indexes will highlight overview
+      attributesToHighlight: ['overview'],
+      highlightPreTag: '<em>',
+      highlightPostTag: '</em>',
+      attributesToSearchOn: ['overview'],
+      indexesOverrides: {
+        movies: {
+          // Only title will be highlighted for hits in movies
+          attributesToHighlight: ['title']
+        }
+      }
+    },
+  }
+)
+```
 ### Modify Meilisearch search parameters
 
 `instantMeiliSearch` returns an instance with two properties on it, one of them being `setMeiliSearchParams`.

packages/instant-meilisearch/__tests__/overridden-meilisearch-parameters.test.ts

@@ -47,5 +47,71 @@ describe('InstantMeiliSearch overridden parameters', () => {
     expect(secondHits[0]._highlightResult?.overview?.value).toContain(
       '<om>While racing to a boxing match</om>'
     )
+
+    setMeiliSearchParams({
+      indexesOverrides: {
+        movies: { highlightPreTag: '<span>', highlightPostTag: '</span>' },
+      },
+    })
+    const thirdResponse = await searchClient.search<Movies>(queryParams)
+
+    const thirdHits = thirdResponse.results[0].hits
+    expect(thirdHits.length).toEqual(1)
+    expect(thirdHits[0]._highlightResult?.overview?.value).toContain(
+      '<span>While racing to a boxing match</span>'
+    )
+  })
+
+  test('sort parameter precedence: per-index overrides global overrides', async () => {
+    await meilisearchClient
+      .index('movies')
+      .updateSettings({
+        sortableAttributes: ['release_date', 'title'],
+      })
+      .waitTask()
+
+    const { searchClient, setMeiliSearchParams } = instantMeiliSearch(
+      'http://localhost:7700',
+      'masterKey',
+      {
+        meiliSearchParams: {
+          sort: ['title:asc'],
+        },
+      }
+    )
+
+    const queryParams = [
+      {
+        indexName: 'movies',
+        params: { query: '', hitsPerPage: 3 },
+      },
+    ]
+
+    // Test global sort override - should sort by title ascending
+    const globalResponse = await searchClient.search<Movies>(queryParams)
+    const globalHits = globalResponse.results[0].hits
+    expect(globalHits.length).toBeGreaterThan(1)
+    // Verify titles are sorted in ascending order
+    const globalTitles = globalHits
+      .map((hit: Movies) => hit.title)
+      .filter(Boolean)
+    expect(globalTitles).toEqual([...globalTitles].sort())
+
+    // Test per-index sort override takes precedence over global
+    setMeiliSearchParams({
+      sort: ['title:asc'],
+      indexesOverrides: {
+        movies: { sort: ['title:desc'] },
+      },
+    })
+
+    const perIndexResponse = await searchClient.search<Movies>(queryParams)
+    const perIndexHits = perIndexResponse.results[0].hits
+    expect(perIndexHits.length).toBeGreaterThan(1)
+    // Verify titles are sorted in descending order
+    const perIndexTitles = perIndexHits
+      .map((hit: Movies) => hit.title)
+      .filter(Boolean)
+    expect(perIndexTitles).toEqual([...perIndexTitles].sort().reverse())
   })
 })

packages/instant-meilisearch/src/adapter/search-request-adapter/__tests__/search-params.test.ts

@@ -80,6 +80,41 @@ describe('Parameters adapter', () => {
     )
   })
 
+  test('adapting a searchContext with overridden Meilisearch parameters for a specific index', () => {
+    const meiliSearchParams: OverridableMeiliSearchSearchParameters = {
+      attributesToHighlight: ['movies', 'genres'],
+      highlightPreTag: '<em>',
+      highlightPostTag: '</em>',
+      matchingStrategy: MatchingStrategies.ALL,
+      indexesOverrides: {
+        test: {
+          attributesToHighlight: ['release_date'],
+          highlightPreTag: '<span>',
+          highlightPostTag: '</span>',
+          matchingStrategy: MatchingStrategies.LAST,
+        },
+      },
+    }
+
+    const searchParams = adaptSearchParams({
+      ...DEFAULT_CONTEXT,
+      meiliSearchParams,
+    })
+
+    expect(searchParams.attributesToHighlight).toEqual(
+      meiliSearchParams.indexesOverrides?.test?.attributesToHighlight
+    )
+    expect(searchParams.highlightPreTag).toEqual(
+      meiliSearchParams.indexesOverrides?.test?.highlightPreTag
+    )
+    expect(searchParams.highlightPostTag).toEqual(
+      meiliSearchParams.indexesOverrides?.test?.highlightPostTag
+    )
+    expect(searchParams.matchingStrategy).toEqual(
+      meiliSearchParams.indexesOverrides?.test?.matchingStrategy
+    )
+  })
+
   test('hybrid search configuration can be set via search parameters', () => {
     const hybridSearchConfig = {
       semanticRatio: 0,
@@ -96,6 +131,29 @@ describe('Parameters adapter', () => {
     expect(searchParams.hybrid).toBe(hybridSearchConfig)
   })
 
+  test('hybrid search configuration can be set via search parameters for a specific index', () => {
+    const hybridSearchConfig = {
+      semanticRatio: 0,
+      embedder: 'default',
+    }
+    const specificHybridSearchConfig = {
+      semanticRatio: 10,
+      embedder: 'default',
+    }
+
+    const searchParams = adaptSearchParams({
+      ...DEFAULT_CONTEXT,
+      meiliSearchParams: {
+        hybrid: hybridSearchConfig,
+        indexesOverrides: {
+          test: { hybrid: specificHybridSearchConfig },
+        },
+      },
+    })
+
+    expect(searchParams.hybrid).toBe(specificHybridSearchConfig)
+  })
+
   test('vector can be set via search parameters', () => {
     const vector = [0, 1, 2]
 
@@ -108,6 +166,20 @@ describe('Parameters adapter', () => {
 
     expect(searchParams.vector).toBe(vector)
   })
+  test('vector can be set via search parameters for a specific index', () => {
+    const vector = [0, 1, 2]
+    const indexVector = [3, 4, 5]
+
+    const searchParams = adaptSearchParams({
+      ...DEFAULT_CONTEXT,
+      meiliSearchParams: {
+        vector,
+        indexesOverrides: { test: { vector: indexVector } },
+      },
+    })
+
+    expect(searchParams.vector).toBe(indexVector)
+  })
 
   test('ranking score threshold can be set via search parameters', () => {
     const rankingScoreThreshold = 0.974
@@ -122,6 +194,23 @@ describe('Parameters adapter', () => {
     expect(searchParams.rankingScoreThreshold).toBe(rankingScoreThreshold)
   })
 
+  test('ranking score threshold can be set via search parameters for a specific index', () => {
+    const rankingScoreThreshold = 0.974
+    const indexRankingScoreThreshold = 0.567
+
+    const searchParams = adaptSearchParams({
+      ...DEFAULT_CONTEXT,
+      meiliSearchParams: {
+        rankingScoreThreshold,
+        indexesOverrides: {
+          test: { rankingScoreThreshold: indexRankingScoreThreshold },
+        },
+      },
+    })
+
+    expect(searchParams.rankingScoreThreshold).toBe(indexRankingScoreThreshold)
+  })
+
   test('distinct search configuration can be set via search parameters', () => {
     const distinctSearchConfig = 'title'
 
@@ -134,6 +223,56 @@ describe('Parameters adapter', () => {
 
     expect(searchParams.distinct).toBe(distinctSearchConfig)
   })
+
+  test('distinct search configuration can be set via search parameters for a specific', () => {
+    const distinctSearchConfig = 'title'
+    const indexDistinctSearchConfig = 'name'
+
+    const searchParams = adaptSearchParams({
+      ...DEFAULT_CONTEXT,
+      meiliSearchParams: {
+        distinct: distinctSearchConfig,
+        indexesOverrides: {
+          test: { distinct: indexDistinctSearchConfig },
+        },
+      },
+    })
+
+    expect(searchParams.distinct).toBe(indexDistinctSearchConfig)
+  })
+
+  test('filter can be set via global override when IS filters are empty', () => {
+    const globalFilter = 'category = "books"'
+
+    const searchParams = adaptSearchParams({
+      ...DEFAULT_CONTEXT,
+      // No facetFilters, filters, or numericFilters - empty IS filters
+      meiliSearchParams: {
+        filter: globalFilter,
+      },
+    })
+
+    expect(searchParams.filter).toBe(globalFilter)
+  })
+
+  test('filter can be set via per-index override when IS filters are empty', () => {
+    const globalFilter = 'category = "books"'
+    const indexFilter = 'status = "active"'
+
+    const searchParams = adaptSearchParams({
+      ...DEFAULT_CONTEXT,
+      // No facetFilters, filters, or numericFilters - empty IS filters
+      meiliSearchParams: {
+        filter: globalFilter,
+        indexesOverrides: {
+          test: { filter: indexFilter },
+        },
+      },
+    })
+
+    // Per-index override should take precedence over global override
+    expect(searchParams.filter).toBe(indexFilter)
+  })
 })
 
 describe('Geo filter adapter', () => {