Add federated search parameters

src/clients/client.ts

@@ -5,8 +5,6 @@
  * Copyright: 2019, MeiliSearch
  */
 
-'use strict';
-
 import { Index } from '../indexes';
 import {
   KeyCreation,
@@ -34,6 +32,8 @@ import {
   DeleteTasksQuery,
   MultiSearchParams,
   MultiSearchResponse,
+  SearchResponse,
+  FederatedMultiSearchParams,
 } from '../types';
 import { HttpRequests } from '../http-requests';
 import { TaskClient, Task } from '../task';
@@ -216,10 +216,18 @@ class Client {
    * @param config - Additional request configuration options
    * @returns Promise containing the search responses
    */
-  async multiSearch<T extends Record<string, any> = Record<string, any>>(
-    queries?: MultiSearchParams,
+  multiSearch<T extends Record<string, unknown> = Record<string, any>>(
+    queries: MultiSearchParams,
+    config?: Partial<Request>,
+  ): Promise<MultiSearchResponse<T>>;
+  multiSearch<T extends Record<string, unknown> = Record<string, any>>(
+    queries: FederatedMultiSearchParams,
+    config?: Partial<Request>,
+  ): Promise<SearchResponse<T>>;
+  async multiSearch<T extends Record<string, unknown> = Record<string, any>>(
+    queries: MultiSearchParams | FederatedMultiSearchParams,
     config?: Partial<Request>,
-  ): Promise<MultiSearchResponse<T>> {
+  ): Promise<MultiSearchResponse<T> | SearchResponse<T>> {
     const url = `multi-search`;
 
     return await this.httpRequest.post(url, queries, undefined, config);

src/types/types.ts

@@ -159,11 +159,21 @@ export type SearchRequestGET = Pagination &
     locales?: Locale[];
   };
 
+export type FederationOptions = { weight: number };
+export type MultiSearchFederation = { limit?: number; offset?: number };
+
 export type MultiSearchQuery = SearchParams & { indexUid: string };
+export type MultiSearchQueryWithFederation = MultiSearchQuery & {
+  federationOptions?: FederationOptions;
+};
 
 export type MultiSearchParams = {
   queries: MultiSearchQuery[];
 };
+export type FederatedMultiSearchParams = {
+  federation: MultiSearchFederation;
+  queries: MultiSearchQueryWithFederation[];
+};
 
 export type CategoriesDistribution = {
   [category: string]: number;
@@ -175,13 +185,6 @@ export type MatchesPosition<T> = Partial<
   Record<keyof T, Array<{ start: number; length: number }>>
 >;
 
-export type Hit<T = Record<string, any>> = T & {
-  _formatted?: Partial<T>;
-  _matchesPosition?: MatchesPosition<T>;
-  _rankingScore?: number;
-  _rankingScoreDetails?: RankingScoreDetails;
-};
-
 export type RankingScoreDetails = {
   words?: {
     order: number;
@@ -213,6 +216,20 @@ export type RankingScoreDetails = {
   [key: string]: Record<string, any> | undefined;
 };
 
+export type FederationDetails = {
+  indexUid: string;
+  queriesPosition: number;
+  weightedRankingScore: number;
+};
+
+export type Hit<T = Record<string, any>> = T & {
+  _formatted?: Partial<T>;
+  _matchesPosition?: MatchesPosition<T>;
+  _rankingScore?: number;
+  _rankingScoreDetails?: RankingScoreDetails;
+  _federation?: FederationDetails;
+};
+
 export type Hits<T = Record<string, any>> = Array<Hit<T>>;
 
 export type FacetStat = { min: number; max: number };

tests/search.test.ts

@@ -143,6 +143,48 @@ describe.each([
     expect(response.results[0].hits[0].title).toEqual('Le Petit Prince');
   });
 
+  test(`${permission} key: Multi index search with federation`, async () => {
+    const client = await getClient(permission);
+
+    const response1 = await client.multiSearch<
+      Books | { id: number; asd: string }
+    >({
+      federation: {},
+      queries: [
+        { indexUid: index.uid, q: '456', attributesToSearchOn: ['id'] },
+        {
+          indexUid: index.uid,
+          q: '1344',
+          federationOptions: { weight: 0.9 },
+          attributesToSearchOn: ['id'],
+        },
+      ],
+    });
+
+    expect(response1).toHaveProperty('hits');
+    expect(Array.isArray(response1.hits)).toBe(true);
+    expect(response1.hits.length).toEqual(2);
+    expect(response1.hits[0].id).toEqual(456);
+
+    const response2 = await client.multiSearch({
+      federation: {},
+      queries: [
+        {
+          indexUid: index.uid,
+          q: '456',
+          federationOptions: { weight: 0.9 },
+          attributesToSearchOn: ['id'],
+        },
+        { indexUid: index.uid, q: '1344', attributesToSearchOn: ['id'] },
+      ],
+    });
+
+    expect(response2).toHaveProperty('hits');
+    expect(Array.isArray(response2.hits)).toBe(true);
+    expect(response2.hits.length).toEqual(2);
+    expect(response2.hits[0].id).toEqual(1344);
+  });
+
   test(`${permission} key: Basic search`, async () => {
     const client = await getClient(permission);
     const response = await client.index(index.uid).search('prince', {});