@openfoodfacts/openfoodfacts-nodejs
    Preparing search index...

    Class SearchApi

    Index

    Constructors

    constructor

    Methods

    autocomplete getDocument getOffDemo getRobotsTxt healthCheck htmlSearch search searchGet

    Constructors

    • Parameters

      • fetch: {
            (input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
            (input: string | Request | URL, init?: RequestInit): Promise<Response>;
        }
          • (input: RequestInfo | URL, init?: RequestInit): Promise<Response>

          • MDN Reference

            Parameters

            • input: RequestInfo | URL
            • Optionalinit: RequestInit

            Returns Promise<Response>

          • (input: string | Request | URL, init?: RequestInit): Promise<Response>

          • MDN Reference

            Parameters

            • input: string | Request | URL
            • Optionalinit: RequestInit

            Returns Promise<Response>

      • options: { baseUrl: string } = ...

      Returns SearchApi

    Methods

    • Parameters

      • query: {
            fuzziness?: number;
            index_id?: string;
            lang?: string;
            q: string;
            size?: number;
            taxonomy_names: string;
        }
        • Optionalfuzziness?: number

          Fuzziness level to use, default to no fuzziness.

        • Optionalindex_id?: string

          Index ID to use for the search, if not provided, the default index is used. If there is only one index, this parameter is not needed.

        • Optionallang?: string

          Language to search in, defaults to 'en'.

        • q: string

          User autocomplete query.

        • Optionalsize?: number

          Number of results to return.

        • taxonomy_names: string

          Name(s) of the taxonomy to search in, as a comma-separated value.

      Returns Promise<
          FetchResponse<
              {
                  parameters: {
                      cookie?: never;
                      header?: never;
                      path?: never;
                      query: {
                          fuzziness?: number;
                          index_id?: string;
                          lang?: string;
                          q: string;
                          size?: number;
                          taxonomy_names: string;
                      };
                  };
                  requestBody?: never;
                  responses: {
                      "200": {
                          content: { "application/json": unknown };
                          headers: { [name: string]: unknown };
                      };
                      "422": {
                          content: {
                              "application/json": {
                                  detail?: { loc: ((...) | (...))[]; msg: string; type: string }[];
                              };
                          };
                          headers: { [name: string]: unknown };
                      };
                  };
              },
              {
                  params: {
                      query: {
                          fuzziness?: number;
                          index_id?: string;
                          lang?: string;
                          q: string;
                          size?: number;
                          taxonomy_names: string;
                      };
                  };
              },
              `${string}/${string}`,
          >,
      >

    • Parameters

      • identifier: string
      • Optionalquery: { index_id?: string }
        • Optionalindex_id?: string

          Index ID to use for the search, if not provided, the default index is used. If there is only one index, this parameter is not needed.

      Returns Promise<
          FetchResponse<
              {
                  parameters: {
                      cookie?: never;
                      header?: never;
                      path: { identifier: string };
                      query?: { index_id?: string };
                  };
                  requestBody?: never;
                  responses: {
                      "200": {
                          content: { "application/json": unknown };
                          headers: { [name: string]: unknown };
                      };
                      "422": {
                          content: {
                              "application/json": {
                                  detail?: { loc: ((...) | (...))[]; msg: string; type: string }[];
                              };
                          };
                          headers: { [name: string]: unknown };
                      };
                  };
              },
              { params: { path: { identifier: string }; query: { index_id?: string } } },
              `${string}/${string}`,
          >,
      >

    • Returns Promise<
          FetchResponse<
              {
                  parameters: {
                      cookie?: never;
                      header?: never;
                      path?: never;
                      query?: never;
                  };
                  requestBody?: never;
                  responses: {
                      "200": {
                          content: { "text/html": string };
                          headers: { [name: string]: unknown };
                      };
                  };
              },
              {},
              `${string}/${string}`,
          >,
      >

    • Returns Promise<
          FetchResponse<
              {
                  parameters: {
                      cookie?: never;
                      header?: never;
                      path?: never;
                      query?: never;
                  };
                  requestBody?: never;
                  responses: {
                      "200": {
                          content: { "text/plain": string };
                          headers: { [name: string]: unknown };
                      };
                  };
              },
              {},
              `${string}/${string}`,
          >,
      >

    • Returns Promise<
          FetchResponse<
              {
                  parameters: {
                      cookie?: never;
                      header?: never;
                      path?: never;
                      query?: never;
                  };
                  requestBody?: never;
                  responses: {
                      "200": {
                          content: { "application/json": unknown };
                          headers: { [name: string]: unknown };
                      };
                  };
              },
              {},
              `${string}/${string}`,
          >,
      >

    • Parameters

      • Optionalquery: {
            display_debug?: boolean;
            index_id?: string;
            langs?: string;
            page?: number;
            page_size?: number;
            q?: string;
            sort_by?: string;
        }
        • Optionaldisplay_debug?: boolean
        • Optionalindex_id?: string

          Index ID to use for the search, if not provided, the default index is used. If there is only one index, this parameter is not needed.

        • Optionallangs?: string
        • Optionalpage?: number
        • Optionalpage_size?: number
        • Optionalq?: string
        • Optionalsort_by?: string

      Returns Promise<
          FetchResponse<
              {
                  parameters: {
                      cookie?: never;
                      header?: never;
                      path?: never;
                      query?: {
                          display_debug?: boolean;
                          index_id?: string;
                          langs?: string;
                          page?: number;
                          page_size?: number;
                          q?: string;
                          sort_by?: string;
                      };
                  };
                  requestBody?: never;
                  responses: {
                      "200": {
                          content: { "text/html": string };
                          headers: { [name: string]: unknown };
                      };
                      "422": {
                          content: {
                              "application/json": {
                                  detail?: { loc: ((...) | (...))[]; msg: string; type: string }[];
                              };
                          };
                          headers: { [name: string]: unknown };
                      };
                  };
              },
              {
                  params: {
                      query: {
                          display_debug?: boolean;
                          index_id?: string;
                          langs?: string;
                          page?: number;
                          page_size?: number;
                          q?: string;
                          sort_by?: string;
                      };
                  };
              },
              `${string}/${string}`,
          >,
      >

    • Parameters

      • body: {
            charts?: (
                | { chart_type: "DistributionChartType"; field: string }
                | { chart_type: "ScatterChartType"; x: string; y: string }
            )[];
            facets?: string[];
            fields?: string[];
            index_id?: string;
            langs: string[];
            page: number;
            page_size: number;
            q?: string;
            sort_by?: string;
            sort_params?: Record<string, unknown>;
        }
        • Optionalcharts?: (
              | { chart_type: "DistributionChartType"; field: string }
              | { chart_type: "ScatterChartType"; x: string; y: string }
          )[]

          Charts

          Name of vega representations to return in the response. Can be distribution chart or scatter plot

        • Optionalfacets?: string[]

          Facets

          Name of facets to return in the response as a comma-separated value. If None (default) no facets are returned.

        • Optionalfields?: string[]

          Fields

          List of fields to include in the response. All other fields will be ignored.

        • Optionalindex_id?: string

          Index Id

          Index ID to use for the search, if not provided, the default index is used. If there is only one index, this parameter is not needed.

        • langs: string[]

          Langs

          List of languages we want to support during search. This list should include the user expected language, and additional languages (such as english for example).

          This is currently used for language-specific subfields to choose in which
subfields we're searching in.

If not provided, `['en']` is used.

          [
                "en"
              ]
        • page: number

          Page

          Page to request, starts at 1.

          1
        • page_size: number

          Page Size

          Number of results to return per page.

          10
        • Optionalq?: string

          Q

          The search query, it supports Lucene search query syntax (https://lucene.apache.org/core/3_6_0/queryparsersyntax.html). Words that are not recognized by the lucene query parser are searched as full text search.

          Example: `categories_tags:"en:beverages" strawberry brands:"casino"` query use a
filter clause for categories and brands and look for "strawberry" in multiple
fields.

The query is optional, but `sort_by` value must then be provided.
        • Optionalsort_by?: string

          Sort By

          Field name to use to sort results, the field should exist and be sortable. If it is not provided, results are sorted by descending relevance score.

          If you put a minus before the name, the results will be sorted by descending order.

If the field name match a known script (defined in your configuration),
it will be use for sorting.

In this case you also need to provide additional parameters corresponding to your script parameters.
If a script needs parameters, you can only use the POST method.

Beware that this may have a big [impact on performance][perf_link]

Also bare in mind [privacy considerations][privacy_link] if your script parameters contains sensible data.

[perf_link]: https://openfoodfacts.github.io/search-a-licious/users/how-to-use-scripts/#performance-considerations
[privacy_link]: https://openfoodfacts.github.io/search-a-licious/users/how-to-use-scripts/#performance-considerations
        • Optionalsort_params?: Record<string, unknown>

          Sort Params

          Additional parameters when using a sort script in sort_by. If the sort script needs parameters, you can only be used the POST method.

      Returns Promise<
          FetchResponse<
              {
                  parameters: {
                      cookie?: never;
                      header?: never;
                      path?: never;
                      query?: never;
                  };
                  requestBody: {
                      content: {
                          "application/json": {
                              charts?: (
                                  | { chart_type: "DistributionChartType"; field: string }
                                  | { chart_type: "ScatterChartType"; x: string; y: string }
                              )[];
                              facets?: string[];
                              fields?: string[];
                              index_id?: string;
                              langs: string[];
                              page: number;
                              page_size: number;
                              q?: string;
                              sort_by?: string;
                              sort_params?: Record<string, unknown>;
                          };
                      };
                  };
                  responses: {
                      "200": {
                          content: { "application/json": unknown };
                          headers: { [name: string]: unknown };
                      };
                      "422": {
                          content: {
                              "application/json": {
                                  detail?: { loc: ((...) | (...))[]; msg: string; type: string }[];
                              };
                          };
                          headers: { [name: string]: unknown };
                      };
                  };
              },
              {
                  body: {
                      charts?: (
                          | { chart_type: "DistributionChartType"; field: string }
                          | { chart_type: "ScatterChartType"; x: string; y: string }
                      )[];
                      facets?: string[];
                      fields?: string[];
                      index_id?: string;
                      langs: string[];
                      page: number;
                      page_size: number;
                      q?: string;
                      sort_by?: string;
                      sort_params?: Record<string, unknown>;
                  };
              },
              `${string}/${string}`,
          >,
      >

    • Parameters

      • query: {
            charts?: string;
            facets?: string;
            fields?: string;
            index_id?: string;
            langs?: string;
            page?: number;
            page_size?: number;
            q?: string;
            sort_by?: string;
        }
        • Optionalcharts?: string

          Name of vega representations to return in the response. Can be distribution chart or scatter plot

        • Optionalfacets?: string

          Name of facets to return in the response as a comma-separated value. If None (default) no facets are returned.

        • Optionalfields?: string

          List of fields to include in the response. All other fields will be ignored.

        • Optionalindex_id?: string

          Index ID to use for the search, if not provided, the default index is used. If there is only one index, this parameter is not needed.

        • Optionallangs?: string

          List of languages we want to support during search. This list should include the user expected language, and additional languages (such as english for example).

          This is currently used for language-specific subfields to choose in which
subfields we're searching in.

If not provided, `['en']` is used.
        • Optionalpage?: number

          Page to request, starts at 1.

        • Optionalpage_size?: number

          Number of results to return per page.

        • Optionalq?: string

          The search query, it supports Lucene search query syntax (https://lucene.apache.org/core/3_6_0/queryparsersyntax.html). Words that are not recognized by the lucene query parser are searched as full text search.

          Example: `categories_tags:"en:beverages" strawberry brands:"casino"` query use a
filter clause for categories and brands and look for "strawberry" in multiple
fields.

The query is optional, but `sort_by` value must then be provided.
        • Optionalsort_by?: string

          Field name to use to sort results, the field should exist and be sortable. If it is not provided, results are sorted by descending relevance score.

          If you put a minus before the name, the results will be sorted by descending order.

If the field name match a known script (defined in your configuration),
it will be use for sorting.

In this case you also need to provide additional parameters corresponding to your script parameters.
If a script needs parameters, you can only use the POST method.

Beware that this may have a big [impact on performance][perf_link]

Also bare in mind [privacy considerations][privacy_link] if your script parameters contains sensible data.

[perf_link]: https://openfoodfacts.github.io/search-a-licious/users/how-to-use-scripts/#performance-considerations
[privacy_link]: https://openfoodfacts.github.io/search-a-licious/users/how-to-use-scripts/#performance-considerations

      Returns Promise<
          FetchResponse<
              {
                  parameters: {
                      cookie?: never;
                      header?: never;
                      path?: never;
                      query?: {
                          charts?: string;
                          facets?: string;
                          fields?: string;
                          index_id?: string;
                          langs?: string;
                          page?: number;
                          page_size?: number;
                          q?: string;
                          sort_by?: string;
                      };
                  };
                  requestBody?: never;
                  responses: {
                      "200": {
                          content: {
                              "application/json": | {
                                  debug: { query: Record<string, unknown> };
                                  errors: { description?: string; title: string }[];
                              }
                              | {
                                  aggregations?: Record<string, unknown>;
                                  charts?: { [key: string]: Record<string, unknown> };
                                  count: number;
                                  debug: { query: Record<string, unknown> };
                                  facets?: {
                                      [key: string]: {
                                          count_error_margin?: number;
                                          items: (...)[];
                                          name: string;
                                      };
                                  };
                                  hits: Record<string, unknown>[];
                                  is_count_exact: boolean;
                                  page: number;
                                  page_count: number;
                                  page_size: number;
                                  timed_out: boolean;
                                  took: number;
                                  warnings?: { description?: string; title: string }[];
                              };
                          };
                          headers: { [name: string]: unknown };
                      };
                      "422": {
                          content: {
                              "application/json": {
                                  detail?: { loc: ((...) | (...))[]; msg: string; type: string }[];
                              };
                          };
                          headers: { [name: string]: unknown };
                      };
                  };
              },
              {
                  params: {
                      query: {
                          charts?: string;
                          facets?: string;
                          fields?: string;
                          index_id?: string;
                          langs?: string;
                          page?: number;
                          page_size?: number;
                          q?: string;
                          sort_by?: string;
                      };
                  };
              },
              `${string}/${string}`,
          >,
      >

    Settings

    Member Visibility

    On This Page

    Constructors
    Methods