Bug 1923689 - Implement basic configuration processing on SearchEngineSelector.

This implements processing the main parts of the search configuration JSON into the Rust structure using serde_json.
Currently the processing applies to:

* The identifier and base properties of the engine records.
* The default engine records.

As variant and environment handling is not yet implemented, the filter function will return all engines defined in the configuration.

Author: Standard8

Cargo.lock

@@ -8,6 +8,9 @@ license = "MPL-2.0"
 
 [dependencies]
 error-support = { path = "../support/error" }
+parking_lot = ">=0.11,<=0.12"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
 thiserror = "1"
 uniffi = { workspace = true }
 

components/search/Cargo.toml

@@ -0,0 +1,135 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+//! This module defines the structures that we use for serde_json to parse
+//! the search configuration.
+
+use crate::{SearchEngineClassification, SearchUrlParam};
+use serde::Deserialize;
+
+/// The list of possible submission methods for search engine urls.
+#[derive(Debug, uniffi::Enum, PartialEq, Deserialize, Clone, Default)]
+#[serde(rename_all = "UPPERCASE")]
+pub(crate) enum JSONEngineMethod {
+    Post = 2,
+    #[serde(other)]
+    #[default]
+    Get = 1,
+}
+
+impl JSONEngineMethod {
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            JSONEngineMethod::Get => "GET",
+            JSONEngineMethod::Post => "POST",
+        }
+    }
+}
+
+/// Defines an individual search engine URL. This is defined separately to
+/// `types::SearchEngineUrl` as various fields may be optional in the supplied
+/// configuration.
+#[derive(Debug, uniffi::Record, PartialEq, Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct JSONEngineUrl {
+    /// The PrePath and FilePath of the URL. May include variables for engines
+    /// which have a variable FilePath, e.g. `{searchTerm}` for when a search
+    /// term is within the path of the url.
+    pub base: String,
+
+    /// The HTTP method to use to send the request (`GET` or `POST`).
+    /// If the engine definition has not specified the method, it defaults to GET.
+    pub method: Option<JSONEngineMethod>,
+
+    /// The parameters for this URL.
+    pub params: Option<Vec<SearchUrlParam>>,
+
+    /// The name of the query parameter for the search term. Automatically
+    /// appended to the end of the query. This may be skipped if `{searchTerm}`
+    /// is included in the base.
+    pub search_term_param_name: Option<String>,
+}
+
+/// Reflects `types::SearchEngineUrls`, but using `EngineUrl`.
+#[derive(Debug, uniffi::Record, PartialEq, Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct JSONEngineUrls {
+    /// The URL to use for searches.
+    pub search: JSONEngineUrl,
+
+    /// The URL to use for suggestions.
+    pub suggestions: Option<JSONEngineUrl>,
+
+    /// The URL to use for trending suggestions.
+    pub trending: Option<JSONEngineUrl>,
+}
+
+/// Represents the engine base section of the configuration.
+#[derive(Debug, Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct JSONEngineBase {
+    /// A list of aliases for this engine.
+    pub aliases: Option<Vec<String>>,
+
+    /// The character set this engine uses for queries. Defaults to 'UTF=8' if not set.
+    pub charset: Option<String>,
+
+    /// The classification of search engine according to the main search types
+    /// (e.g. general, shopping, travel, dictionary). Currently, only marking as
+    /// a general search engine is supported.
+    pub classification: SearchEngineClassification,
+
+    /// The user visible name for the search engine.
+    pub name: String,
+
+    /// The partner code for the engine. This will be inserted into parameters
+    /// which include `{partnerCode}`.
+    pub partner_code: Option<String>,
+
+    /// The URLs associated with the search engine.
+    pub urls: JSONEngineUrls,
+}
+
+/// Represents an individual engine record in the configuration.
+#[derive(Debug, Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct JSONEngineRecord {
+    pub identifier: String,
+    pub base: JSONEngineBase,
+}
+
+/// Represents the default engines record.
+#[derive(Debug, Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct JSONDefaultEnginesRecord {
+    pub global_default: String,
+    pub global_default_private: Option<String>,
+}
+
+/// Represents the engine orders record.
+#[derive(Debug, Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct JSONEngineOrdersRecord {
+    // TODO: Implementation.
+}
+
+/// Represents an individual record in the raw search configuration.
+#[derive(Debug, Deserialize, Clone)]
+#[serde(tag = "recordType", rename_all = "camelCase")]
+pub(crate) enum JSONSearchConfigurationRecords {
+    DefaultEngines(JSONDefaultEnginesRecord),
+    Engine(Box<JSONEngineRecord>),
+    EngineOrders(JSONEngineOrdersRecord),
+    // Include some flexibilty if we choose to add new record types in future.
+    // Current versions of the application receiving the configuration will
+    // ignore the new record types.
+    #[serde(other)]
+    Unknown,
+}
+
+/// Represents the search configuration as received from remote settings.
+#[derive(Debug, Deserialize)]
+pub(crate) struct JSONSearchConfiguration {
+    pub data: Vec<JSONSearchConfigurationRecords>,
+}

components/search/src/configuration_types.rs

@@ -11,8 +11,10 @@ use error_support::{ErrorHandling, GetErrorHandling};
 /// application.
 #[derive(Debug, thiserror::Error)]
 pub enum Error {
-    #[error("NotImplemented")]
-    NotImplemented,
+    #[error("Search configuration not specified")]
+    SearchConfigNotSpecified,
+    #[error("JSON error: {0}")]
+    Json(#[from] serde_json::Error),
 }
 
 // #[non_exhaustive]

components/search/src/error.rs

@@ -0,0 +1,204 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use crate::{
+    error::Error, JSONEngineBase, JSONEngineRecord, JSONEngineUrl, JSONEngineUrls,
+    JSONSearchConfigurationRecords, RefinedSearchConfig, SearchEngineDefinition, SearchEngineUrl,
+    SearchEngineUrls, SearchUserEnvironment,
+};
+
+impl From<JSONEngineUrl> for SearchEngineUrl {
+    fn from(url: JSONEngineUrl) -> Self {
+        Self {
+            base: url.base,
+            method: url.method.unwrap_or_default().as_str().to_string(),
+            params: url.params.unwrap_or_default(),
+            search_term_param_name: url.search_term_param_name,
+        }
+    }
+}
+
+impl From<JSONEngineUrls> for SearchEngineUrls {
+    fn from(urls: JSONEngineUrls) -> Self {
+        Self {
+            search: urls.search.into(),
+            suggestions: None,
+            trending: None,
+        }
+    }
+}
+
+impl SearchEngineDefinition {
+    pub(crate) fn from_configuration_details(
+        identifier: &str,
+        base: JSONEngineBase,
+    ) -> SearchEngineDefinition {
+        SearchEngineDefinition {
+            aliases: base.aliases.unwrap_or_default(),
+            charset: base.charset.unwrap_or_else(|| "UTF-8".to_string()),
+            classification: base.classification,
+            identifier: identifier.to_string(),
+            name: base.name,
+            order_hint: None,
+            partner_code: base.partner_code.unwrap_or_default(),
+            telemetry_suffix: None,
+            urls: base.urls.into(),
+        }
+    }
+}
+
+pub(crate) fn filter_engine_configuration(
+    user_environment: SearchUserEnvironment,
+    configuration: Vec<JSONSearchConfigurationRecords>,
+) -> Result<RefinedSearchConfig, Error> {
+    let mut engines = Vec::new();
+    let mut default_engine_id: Option<String> = None;
+    let mut default_private_engine_id: Option<String> = None;
+
+    for record in configuration {
+        match record {
+            JSONSearchConfigurationRecords::Engine(engine) => {
+                let result = extract_engine_config(&user_environment, engine);
+                engines.extend(result);
+            }
+            JSONSearchConfigurationRecords::DefaultEngines(default_engines) => {
+                default_engine_id = Some(default_engines.global_default);
+                default_private_engine_id.clone_from(&default_engines.global_default_private);
+            }
+            JSONSearchConfigurationRecords::EngineOrders(_engine_orders) => {
+                // TODO: Implementation.
+            }
+            JSONSearchConfigurationRecords::Unknown => {
+                // Prevents panics if a new record type is added in future.
+            }
+        }
+    }
+
+    Ok(RefinedSearchConfig {
+        engines,
+        app_default_engine_id: default_engine_id.unwrap(),
+        app_default_private_engine_id: default_private_engine_id,
+    })
+}
+
+fn extract_engine_config(
+    _user_environment: &SearchUserEnvironment,
+    record: Box<JSONEngineRecord>,
+) -> Option<SearchEngineDefinition> {
+    // TODO: Variant handling.
+    Some(SearchEngineDefinition::from_configuration_details(
+        &record.identifier,
+        record.base,
+    ))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::types::*;
+
+    #[test]
+    fn test_from_configuration_details_fallsback_to_defaults() {
+        let result = SearchEngineDefinition::from_configuration_details(
+            "test",
+            JSONEngineBase {
+                aliases: None,
+                charset: None,
+                classification: SearchEngineClassification::General,
+                name: "Test".to_string(),
+                partner_code: None,
+                urls: JSONEngineUrls {
+                    search: JSONEngineUrl {
+                        base: "https://example.com".to_string(),
+                        method: None,
+                        params: None,
+                        search_term_param_name: None,
+                    },
+                    suggestions: None,
+                    trending: None,
+                },
+            },
+        );
+
+        assert_eq!(
+            result,
+            SearchEngineDefinition {
+                aliases: Vec::new(),
+                charset: "UTF-8".to_string(),
+                classification: SearchEngineClassification::General,
+                identifier: "test".to_string(),
+                partner_code: String::new(),
+                name: "Test".to_string(),
+                order_hint: None,
+                telemetry_suffix: None,
+                urls: SearchEngineUrls {
+                    search: SearchEngineUrl {
+                        base: "https://example.com".to_string(),
+                        method: "GET".to_string(),
+                        params: Vec::new(),
+                        search_term_param_name: None,
+                    },
+                    suggestions: None,
+                    trending: None
+                }
+            }
+        )
+    }
+
+    #[test]
+    fn test_from_configuration_details_uses_values() {
+        let result = SearchEngineDefinition::from_configuration_details(
+            "test",
+            JSONEngineBase {
+                aliases: Some(vec!["foo".to_string(), "bar".to_string()]),
+                charset: Some("ISO-8859-15".to_string()),
+                classification: SearchEngineClassification::Unknown,
+                name: "Test".to_string(),
+                partner_code: Some("firefox".to_string()),
+                urls: JSONEngineUrls {
+                    search: JSONEngineUrl {
+                        base: "https://example.com".to_string(),
+                        method: Some(crate::JSONEngineMethod::Post),
+                        params: Some(vec![SearchUrlParam {
+                            name: "param".to_string(),
+                            value: Some("test param".to_string()),
+                            experiment_config: None,
+                        }]),
+                        search_term_param_name: Some("baz".to_string()),
+                    },
+                    suggestions: None,
+                    trending: None,
+                },
+            },
+        );
+
+        assert_eq!(
+            result,
+            SearchEngineDefinition {
+                aliases: vec!["foo".to_string(), "bar".to_string()],
+                charset: "ISO-8859-15".to_string(),
+                classification: SearchEngineClassification::Unknown,
+                identifier: "test".to_string(),
+                partner_code: "firefox".to_string(),
+                name: "Test".to_string(),
+                order_hint: None,
+                telemetry_suffix: None,
+                urls: SearchEngineUrls {
+                    search: SearchEngineUrl {
+                        base: "https://example.com".to_string(),
+                        method: "POST".to_string(),
+                        params: vec![SearchUrlParam {
+                            name: "param".to_string(),
+                            value: Some("test param".to_string()),
+                            experiment_config: None,
+                        }],
+                        search_term_param_name: Some("baz".to_string()),
+                    },
+                    suggestions: None,
+                    trending: None
+                }
+            }
+        )
+    }
+}

components/search/src/filter.rs

@@ -2,12 +2,15 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
+mod configuration_types;
 mod error;
+mod filter;
 pub use error::SearchApiError;
 
 pub mod selector;
 pub mod types;
 
+pub(crate) use crate::configuration_types::*;
 pub use crate::types::*;
 pub use selector::SearchEngineSelector;
 pub type SearchApiResult<T> = std::result::Result<T, error::SearchApiError>;