refactor(object)!: remove AstarteAgregate completelly

Introduce the AstarteObject type, which replaces the HashMap for objects
with an array and remove the conversion trait with a TryFrom.

Signed-off-by: Joshua Chapman <joshua.chapman@secomind.com>

Author: joshuachp

astarte-device-sdk-derive/src/lib.rs

@@ -155,29 +155,27 @@ impl ObjectDerive {
 
         let name = &self.name;
         let (impl_generics, ty_generics, where_clause) = self.generics.split_for_impl();
+        let capacity = self.fields.len();
         let fields = self.fields.iter().map(|i| {
             let name = i.to_string();
             let name = rename_rule.apply_to_field(&name);
             quote_spanned! {i.span() =>
                 // TODO *Temporarily* ignore this new lint will be fixed in a new pr
                 #[allow(unknown_lints)]
                 #[allow(clippy::unnecessary_fallible_conversions)]
-                let value: astarte_device_sdk::types::AstarteType = std::convert::TryInto::try_into(self.#i)?;
-                result.insert(#name.to_string(), value);
+                let v: astarte_device_sdk::types::AstarteType = ::std::convert::TryInto::try_into(value.#i)?;
+                object.insert(#name.to_string(), v);
             }
         });
 
         quote! {
-            impl #impl_generics astarte_device_sdk::IntoAstarteObject for #name #ty_generics #where_clause {
-                fn into_astarte_object(
-                    self,
-                ) -> ::std::result::Result<
-                    std::collections::HashMap<String, astarte_device_sdk::types::AstarteType>,
-                    astarte_device_sdk::error::Error,
-                > {
-                    let mut result = std::collections::HashMap::new();
+            impl #impl_generics ::std::convert::TryFrom<#name #ty_generics> for astarte_device_sdk::aggregate::AstarteObject #where_clause {
+                type Error = astarte_device_sdk::error::Error;
+
+                fn try_from(value: #name #ty_generics) -> ::std::result::Result<Self, Self::Error> {
+                    let mut object = Self::with_capacity(#capacity);
                     #(#fields)*
-                    Ok(result)
+                    Ok(object)
                 }
             }
         }

astarte-device-sdk-mock/src/lib.rs

@@ -19,35 +19,32 @@
 use std::{future::Future, path::Path};
 
 use astarte_device_sdk::{
+    aggregate::AstarteObject,
     client::{ClientDisconnect, RecvError},
     properties::PropAccess,
     store::StoredProp,
-    AstarteType, DeviceEvent, Error, Interface, IntoAstarteObject,
+    AstarteType, DeviceEvent, Error, Interface,
 };
 use mockall::mock;
 
 // Export public facing dependencies
 pub use mockall;
 
 pub trait Client {
-    fn send_object_with_timestamp<D>(
+    fn send_object_with_timestamp(
         &self,
         interface_name: &str,
         interface_path: &str,
-        data: D,
+        data: AstarteObject,
         timestamp: chrono::DateTime<chrono::Utc>,
-    ) -> impl Future<Output = Result<(), Error>> + Send
-    where
-        D: IntoAstarteObject + Send + 'static;
+    ) -> impl Future<Output = Result<(), Error>> + Send;
 
-    fn send_object<D>(
+    fn send_object(
         &self,
         interface_name: &str,
         interface_path: &str,
-        data: D,
-    ) -> impl Future<Output = Result<(), Error>> + Send
-    where
-        D: IntoAstarteObject + Send + 'static;
+        data: AstarteObject,
+    ) -> impl Future<Output = Result<(), Error>> + Send;
 
     fn send_with_timestamp<D>(
         &self,
@@ -137,24 +134,20 @@ mock! {
     pub DeviceClient<S: 'static> { }
 
     impl<S: Send + Sync> Client for DeviceClient<S> {
-        async fn send_object_with_timestamp<D>(
+        async fn send_object_with_timestamp(
             &self,
             interface_name: &str,
             interface_path: &str,
-            data: D,
+            data: AstarteObject,
             timestamp: chrono::DateTime<chrono::Utc>,
-        ) -> Result<(), Error>
-        where
-            D: IntoAstarteObject + Send + 'static;
+        ) -> Result<(), Error>;
 
-        async fn send_object<D>(
+        async fn send_object(
             &self,
             interface_name: &str,
             interface_path: &str,
-            data: D,
-        ) -> Result<(), Error>
-        where
-            D: IntoAstarteObject + Send + 'static;
+            data: AstarteObject,
+        ) -> Result<(), Error>;
 
         async fn send_with_timestamp<D>(
             &self,
@@ -245,16 +238,13 @@ mod tests {
     struct CheckMocks {}
 
     impl Client for CheckMocks {
-        async fn send_object_with_timestamp<D>(
+        async fn send_object_with_timestamp(
             &self,
             interface_name: &str,
             interface_path: &str,
-            data: D,
+            data: AstarteObject,
             timestamp: chrono::DateTime<chrono::Utc>,
-        ) -> Result<(), Error>
-        where
-            D: IntoAstarteObject + Send + 'static,
-        {
+        ) -> Result<(), Error> {
             astarte_device_sdk::Client::send_object_with_timestamp(
                 self,
                 interface_name,
@@ -265,15 +255,12 @@ mod tests {
             .await
         }
 
-        async fn send_object<D>(
+        async fn send_object(
             &self,
             interface_name: &str,
             interface_path: &str,
-            data: D,
-        ) -> Result<(), Error>
-        where
-            D: IntoAstarteObject + Send + 'static,
-        {
+            data: AstarteObject,
+        ) -> Result<(), Error> {
             astarte_device_sdk::Client::send_object(self, interface_name, interface_path, data)
                 .await
         }
@@ -320,28 +307,22 @@ mod tests {
     }
 
     impl astarte_device_sdk::Client for CheckMocks {
-        async fn send_object_with_timestamp<D>(
+        async fn send_object_with_timestamp(
             &self,
             _interface_name: &str,
             _interface_path: &str,
-            _data: D,
+            _data: AstarteObject,
             _timestamp: chrono::DateTime<chrono::Utc>,
-        ) -> Result<(), Error>
-        where
-            D: IntoAstarteObject + Send,
-        {
+        ) -> Result<(), Error> {
             Ok(())
         }
 
-        async fn send_object<D>(
+        async fn send_object(
             &self,
             _interface_name: &str,
             _interface_path: &str,
-            _data: D,
-        ) -> Result<(), Error>
-        where
-            D: IntoAstarteObject + Send,
-        {
+            _data: AstarteObject,
+        ) -> Result<(), Error> {
             Ok(())
         }
 

docs/get-started.md

@@ -554,13 +554,13 @@ interface.
 # use tokio::task::JoinSet;
 # use tracing::info;
 # #[cfg(not(feature = "derive"))]
-# use astarte_device_sdk_derive::AstarteAggregate;
+# use astarte_device_sdk_derive::IntoAstarteObject;
 # /// Load connection configuration and connect a device to Astarte.
 # async fn init() -> eyre::Result<(DeviceClient<SqliteStore>,DeviceConnection<SqliteStore, Mqtt<SqliteStore>>)> {
 #     todo!()
 # }
 
-#[derive(Debug, AstarteAggregate)]
+#[derive(Debug, IntoAstarteObject)]
 struct DataObject {
     double_endpoint: f64,
     string_endpoint: String,
@@ -585,7 +585,7 @@ async fn send_aggregate(client: DeviceClient<SqliteStore>) -> eyre::Result<()> {
             .send_object(
                 "org.astarte-platform.rust.get-started.Aggregated",
                 "/group_data",
-                data,
+                data.try_into()?,
             )
             .await?;
 

e2e-test/src/main.rs

@@ -237,7 +237,7 @@ async fn main() -> eyre::Result<()> {
                         sensor_n.remove(0);
                         rx_data.0 = sensor_n;
 
-                        for (key, value) in var {
+                        for (key, value) in var.into_key_values() {
                             rx_data.1.insert(key, value);
                         }
                     } else if event.interface == test_cfg.interface_property_so {
@@ -412,7 +412,7 @@ async fn test_aggregate_device_to_server(
         .send_object(
             &test_cfg.interface_aggregate_do,
             &format!("/{sensor_number}"),
-            tx_data.clone(),
+            tx_data.clone().try_into().unwrap(),
         )
         .await?;
 

examples/object_datastream/main.rs

@@ -25,7 +25,7 @@ use astarte_device_sdk::{
     transport::mqtt::MqttConfig,
 };
 #[cfg(not(feature = "derive"))]
-use astarte_device_sdk_derive::AstarteAggregate;
+use astarte_device_sdk_derive::IntoAstarteObject;
 
 #[derive(Serialize, Deserialize)]
 struct Config {
@@ -81,7 +81,7 @@ async fn main() -> Result<(), Error> {
                 .send_object(
                     "org.astarte-platform.rust.examples.object-datastream.DeviceDatastream",
                     "/23",
-                    data,
+                    data.try_into().unwrap(),
                 )
                 .await
                 .unwrap();