Implement the experimental feature for remote federated search requests.

src/meilisearch.ts

@@ -28,6 +28,7 @@ import type {
   BatchesResults,
   BatchesQuery,
   MultiSearchResponseOrSearchResponse,
+  Network,
 } from "./types.js";
 import { ErrorStatusCode } from "./types.js";
 import { HttpRequests } from "./http-requests.js";
@@ -201,7 +202,8 @@ export class MeiliSearch {
    * Perform multiple search queries.
    *
    * It is possible to make multiple search queries on the same index or on
-   * different ones
+   * different ones. With network feature enabled, you can also search across
+   * remote instances.
    *
    * @example
    *
@@ -212,11 +214,33 @@ export class MeiliSearch {
    *     { indexUid: "books", q: "flower" },
    *   ],
    * });
+   *
+   * // Federated search with remote instance (requires network feature enabled)
+   * client.multiSearch({
+   *   federation: {},
+   *   queries: [
+   *     {
+   *       indexUid: "movies",
+   *       q: "wonder",
+   *       federationOptions: {
+   *         remote: "meilisearch instance name",
+   *       },
+   *     },
+   *     {
+   *       indexUid: "movies",
+   *       q: "wonder",
+   *       federationOptions: {
+   *         remote: "meilisearch instance name",
+   *       },
+   *     },
+   *   ],
+   * });
    * ```
    *
    * @param queries - Search queries
    * @param extraRequestInit - Additional request configuration options
    * @returns Promise containing the search responses
+   * @see {@link https://www.meilisearch.com/docs/learn/multi_search/implement_sharding#perform-a-search}
    */
   async multiSearch<
     T1 extends MultiSearchParams | FederatedMultiSearchParams,
@@ -234,6 +258,31 @@ export class MeiliSearch {
     });
   }
 
+  ///
+  ///  Network
+  ///
+
+  /**
+   * {@link https://www.meilisearch.com/docs/reference/api/network#get-the-network-object}
+   *
+   * @experimental
+   */
+  async getNetwork(): Promise<Network> {
+    return await this.httpRequest.get({ path: "network" });
+  }
+
+  /**
+   * {@link https://www.meilisearch.com/docs/reference/api/network#update-the-network-object}
+   *
+   * @experimental
+   */
+  async updateNetwork(network: Partial<Network>): Promise<Network> {
+    return await this.httpRequest.patch({
+      path: "network",
+      body: network,
+    });
+  }
+
   ///
   /// TASKS
   ///

src/types.ts

@@ -253,7 +253,7 @@ export type MergeFacets = {
   maxValuesPerFacet?: number | null;
 };
 
-export type FederationOptions = { weight: number };
+export type FederationOptions = { weight: number; remote?: string };
 export type MultiSearchFederation = {
   limit?: number;
   offset?: number;
@@ -274,6 +274,26 @@ export type FederatedMultiSearchParams = {
   queries: MultiSearchQueryWithFederation[];
 };
 
+/**
+ * {@link https://www.meilisearch.com/docs/reference/api/network#the-remote-object}
+ *
+ * @see `meilisearch_types::features::Remote` at {@link https://github.com/meilisearch/meilisearch}
+ */
+export type Remote = {
+  url: string;
+  searchApiKey: string | null;
+};
+
+/**
+ * {@link https://www.meilisearch.com/docs/reference/api/network#the-network-object}
+ *
+ * @see `meilisearch_types::features::Network` at {@link https://github.com/meilisearch/meilisearch}
+ */
+export type Network = {
+  self: string | null;
+  remotes: Record<string, Remote>;
+};
+
 export type CategoriesDistribution = {
   [category: string]: number;
 };

tests/client.test.ts

@@ -899,3 +899,35 @@ describe.each([
     );
   });
 });
+
+describe.each([{ permission: "Master" }])(
+  "Test network methods",
+  ({ permission }) => {
+    const instanceName = "instance_1";
+
+    test(`${permission} key: Update and get network settings`, async () => {
+      const client = await getClient(permission);
+
+      const instances = {
+        [instanceName]: {
+          url: "http://instance-1:7700",
+          searchApiKey: "search-key-1",
+        },
+      };
+
+      await client.updateNetwork({ self: instanceName, remotes: instances });
+      const response = await client.getNetwork();
+      expect(response).toHaveProperty("self", instanceName);
+      expect(response).toHaveProperty("remotes");
+      expect(response.remotes).toHaveProperty("instance_1");
+      expect(response.remotes["instance_1"]).toHaveProperty(
+        "url",
+        instances[instanceName].url,
+      );
+      expect(response.remotes["instance_1"]).toHaveProperty(
+        "searchApiKey",
+        instances[instanceName].searchApiKey,
+      );
+    });
+  },
+);

tests/search.test.ts

@@ -22,6 +22,7 @@ import {
   getClient,
   datasetWithNests,
   getKey,
+  HOST,
 } from "./utils/meilisearch-test-utils.js";
 
 const index = {
@@ -235,6 +236,60 @@ describe.each([
     expect(response2.hits[0].id).toEqual(1344);
   });
 
+  test(`${permission} key: Multi index search with federation and remote`, async () => {
+    const adminKey = await getKey("Admin");
+
+    // first enable the network endpoint.
+    await fetch(`${HOST}/experimental-features`, {
+      body: JSON.stringify({ network: true }),
+      headers: {
+        Authorization: `Bearer ${adminKey}`,
+        "Content-Type": "application/json",
+      },
+      method: "PATCH",
+    });
+
+    const masterClient = await getClient("Master");
+
+    const searchKey = await getKey("Search");
+
+    // set the remote name and instances
+    const instanceName = "instance_1";
+    await masterClient.updateNetwork({
+      self: instanceName,
+      remotes: { [instanceName]: { url: HOST, searchApiKey: searchKey } },
+    });
+
+    const searchClient = await getClient(permission);
+
+    const response = await searchClient.multiSearch<
+      FederatedMultiSearchParams,
+      Books | { id: number; asd: string }
+    >({
+      federation: {},
+      queries: [
+        {
+          indexUid: index.uid,
+          q: "456",
+          attributesToSearchOn: ["id"],
+          federationOptions: { weight: 1, remote: instanceName },
+        },
+        {
+          indexUid: index.uid,
+          q: "1344",
+          federationOptions: { weight: 0.9, remote: instanceName },
+          attributesToSearchOn: ["id"],
+        },
+      ],
+    });
+
+    expect(response).toHaveProperty("hits");
+    expect(Array.isArray(response.hits)).toBe(true);
+    expect(response.hits.length).toEqual(2);
+    expect(response.hits[0].id).toEqual(456);
+    expect(response.hits[0]._federation).toHaveProperty("remote", instanceName);
+  });
+
   test(`${permission} key: Multi search with facetsByIndex`, async () => {
     const client = await getClient(permission);
     const masterClient = await getClient("Master");