Add name to Valhalla waypoint properties

Exposes the Valhalla 'name' location property on ValhallaWaypointProperties
so waypoints can carry a location/business name, which Valhalla may use in
route narration (e.g. "You have arrived at <business name>").

Notes:
- ValhallaWaypointProperties loses Copy since String is not Copy.
- The field is serialized as 'waypoint_name' in the internal waypoint
  properties blob (the request still sends 'name'). This avoids a key
  collision with OsrmWaypointProperties: waypoints rebuilt from a parsed
  route response reuse the same properties blob, and on reroute the OSRM
  snapped street name would otherwise deserialize into the Valhalla name
  and be sent to the server. A regression test covers this.

Author: freszu

common/ferrostar/src/routing_adapters/valhalla.rs

@@ -30,11 +30,24 @@ use tsify::Tsify;
 ///
 /// NOTE: Waypoint properties will NOT currently be echoed back in OSRM format,
 /// so these are sent to the server one time.
-#[derive(Copy, Clone, PartialEq, Debug, Default, Serialize, Deserialize)]
+#[derive(Clone, PartialEq, Debug, Default, Serialize, Deserialize)]
 #[cfg_attr(feature = "uniffi", derive(uniffi::Record))]
 #[cfg_attr(feature = "wasm-bindgen", derive(Tsify))]
 #[cfg_attr(feature = "wasm-bindgen", tsify(into_wasm_abi, from_wasm_abi))]
 pub struct ValhallaWaypointProperties {
+    /// Location or business name.
+    ///
+    /// The name may be used in the route narration directions,
+    /// such as "You have arrived at <business name>."
+    ///
+    /// NOTE: Serialized as `waypoint_name` in the waypoint properties blob so it cannot
+    /// collide with the `name` of [`OsrmWaypointProperties`](crate::routing_adapters::osrm::models::OsrmWaypointProperties)
+    /// (the snapped street name), which occupies the same blob on waypoints rebuilt from a
+    /// route response (e.g. the remaining waypoints used for reroute requests).
+    /// It is still sent to Valhalla as `name`.
+    #[serde(rename = "waypoint_name")]
+    #[cfg_attr(feature = "uniffi", uniffi(default))]
+    pub name: Option<String>,
     /// Preferred direction of travel for the start from the location.
     ///
     /// The heading is indicated in degrees from north in a clockwise direction, where north is 0°, east is 90°, south is 180°, and west is 270°.
@@ -503,6 +516,7 @@ fn merge_optional_waypoint_properties(
     waypoint_properties: Option<ValhallaWaypointProperties>,
 ) -> JsonValue {
     let Some(ValhallaWaypointProperties {
+        name,
         heading,
         heading_tolerance,
         minimum_reachability,
@@ -531,6 +545,10 @@ fn merge_optional_waypoint_properties(
         }
     }
 
+    if let Some(name) = name {
+        result["name"] = name.into();
+    }
+
     if let Some(heading) = heading {
         result["heading"] = heading.into();
     }
@@ -629,6 +647,7 @@ mod tests {
                 GeographicCoordinate { lat: 2.0, lng: 3.0 },
                 WaypointKind::Break,
                 ValhallaWaypointProperties {
+                    name: Some("Main Street Stop".to_string()),
                     preferred_side: Some(ValhallaWaypointPreferredSide::Same),
                     search_filter: Some(ValhallaLocationSearchFilter {
                         exclude_bridge: Some(true),
@@ -702,6 +721,7 @@ mod tests {
                     {
                         "lat": 2.0,
                         "lon": 3.0,
+                        "name": "Main Street Stop",
                     }
                 ],
             })
@@ -928,4 +948,44 @@ mod tests {
             })
         );
     }
+
+    /// Waypoints rebuilt from a parsed route (e.g. the remaining waypoints used when rerouting)
+    /// carry [`OsrmWaypointProperties`] in the properties blob, whose `name` is the snapped
+    /// street name. That name must NOT leak into the generated request as a Valhalla
+    /// location `name`.
+    #[test]
+    fn osrm_response_properties_do_not_leak_into_request() {
+        use crate::routing_adapters::osrm::models::OsrmWaypointProperties;
+
+        let waypoint = Waypoint {
+            coordinate: GeographicCoordinate { lat: 2.0, lng: 3.0 },
+            kind: WaypointKind::Break,
+            properties: Some(
+                serde_json::to_vec(&OsrmWaypointProperties {
+                    name: Some("Snapped Street".to_string()),
+                    distance: Some(4.2),
+                })
+                .expect("Infallible JSON serialization"),
+            ),
+        };
+
+        let body_json = generate_body(
+            USER_LOCATION,
+            vec![
+                Waypoint {
+                    coordinate: GeographicCoordinate { lat: 0.0, lng: 1.0 },
+                    kind: WaypointKind::Break,
+                    properties: None,
+                },
+                waypoint,
+            ],
+            None,
+        );
+
+        assert_eq!(
+            body_json["locations"][2].get("name"),
+            None,
+            "OSRM snapped street name must not become a Valhalla location name"
+        );
+    }
 }