Merge pull request #106 from chrivers/chrivers/hue-crate-refactor

Refactor code to move all hue-related code entirely into the hue crate (`crates/hue/`)

This improves rebuild times, and makes it easier to reuse parts of the Bifrost code in other projects.

Author: chrivers

crates/hue/Cargo.toml

@@ -18,11 +18,15 @@ workspace = true
 [dependencies]
 bitflags = "2.8.0"
 byteorder = "1.5.0"
-chrono = { version = "0.4.39", default-features = false }
+chrono = { version = "0.4.39", default-features = false, features = ["clock", "std"] }
+hex = "0.4.3"
+iana-time-zone = "0.1.61"
+mac_address = { version = "1.1.8", features = ["serde"] }
 packed_struct = "0.10.1"
 serde = { version = "1.0.217", features = ["derive"] }
+serde_json = "1.0.140"
 thiserror = "2.0.11"
-uuid = "1.13.1"
+uuid = { version = "1.13.1", features = ["serde", "v5"] }
 
 [dev-dependencies]
 hex = "0.4.3"

src/hue/api/device.rs crates/hue/src/api/device.rs

@@ -3,9 +3,9 @@ use std::ops::{AddAssign, Sub};
 
 use serde::{Deserialize, Serialize};
 
-use crate::hue::api::{Metadata, MetadataUpdate, RType, ResourceLink, Stub};
-use crate::hue::version::SwVersion;
-use crate::hue::HUE_BRIDGE_V2_MODEL_ID;
+use crate::api::{Metadata, MetadataUpdate, RType, ResourceLink, Stub};
+use crate::version::SwVersion;
+use crate::HUE_BRIDGE_V2_MODEL_ID;
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct Device {

src/hue/api/entertainment.rs crates/hue/src/api/entertainment.rs

@@ -1,6 +1,6 @@
 use serde::{Deserialize, Serialize};
 
-use crate::hue::api::ResourceLink;
+use crate::api::ResourceLink;
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct Entertainment {

src/hue/api/entertainment_config.rs crates/hue/src/api/entertainment_config.rs

@@ -1,6 +1,6 @@
 use serde::{Deserialize, Serialize};
 
-use crate::hue::api::ResourceLink;
+use crate::api::ResourceLink;
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct EntertainmentConfiguration {

src/hue/api/grouped_light.rs crates/hue/src/api/grouped_light.rs

@@ -1,9 +1,8 @@
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 
-use hue::xy::XY;
-
-use crate::hue::api::{ColorTemperatureUpdate, ColorUpdate, DimmingUpdate, On, ResourceLink, Stub};
+use crate::api::{ColorTemperatureUpdate, ColorUpdate, DimmingUpdate, On, ResourceLink, Stub};
+use crate::xy::XY;
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct GroupedLight {

src/hue/api/light.rs crates/hue/src/api/light.rs

@@ -4,9 +4,8 @@ use std::ops::{AddAssign, Sub};
 use serde::{Deserialize, Serialize};
 use serde_json::{json, Value};
 
-use hue::xy::XY;
-
-use crate::hue::api::{DeviceArchetype, Identify, Metadata, MetadataUpdate, ResourceLink, Stub};
+use crate::api::{DeviceArchetype, Identify, Metadata, MetadataUpdate, ResourceLink, Stub};
+use crate::xy::XY;
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct Light {

src/hue/api/mod.rs crates/hue/src/api/mod.rs

@@ -57,8 +57,8 @@ use std::fmt::Debug;
 use serde::{Deserialize, Serialize};
 use serde_json::{from_value, json, Value};
 
-use crate::error::{ApiError, ApiResult};
-use crate::hue::legacy_api::ApiLightStateUpdate;
+use crate::error::{HueError, HueResult};
+use crate::legacy_api::ApiLightStateUpdate;
 
 #[derive(Debug, Deserialize, Clone, Default)]
 #[serde(deny_unknown_fields)]
@@ -189,7 +189,7 @@ impl Resource {
         }
     }
 
-    pub fn from_value(rtype: RType, obj: Value) -> ApiResult<Self> {
+    pub fn from_value(rtype: RType, obj: Value) -> HueResult<Self> {
         let res = match rtype {
             RType::AuthV1 => Self::AuthV1(from_value(obj)?),
             RType::BehaviorInstance => Self::BehaviorInstance(from_value(obj)?),
@@ -232,37 +232,37 @@ impl Resource {
 macro_rules! resource_conversion_impl {
     ( $name:ident ) => {
         impl<'a> TryFrom<&'a mut Resource> for &'a mut $name {
-            type Error = ApiError;
+            type Error = HueError;
 
             fn try_from(value: &'a mut Resource) -> Result<Self, Self::Error> {
                 if let Resource::$name(obj) = value {
                     Ok(obj)
                 } else {
-                    Err(ApiError::WrongType(RType::Light, value.rtype()))
+                    Err(HueError::WrongType(RType::Light, value.rtype()))
                 }
             }
         }
 
         impl<'a> TryFrom<&'a Resource> for &'a $name {
-            type Error = ApiError;
+            type Error = HueError;
 
             fn try_from(value: &'a Resource) -> Result<Self, Self::Error> {
                 if let Resource::$name(obj) = value {
                     Ok(obj)
                 } else {
-                    Err(ApiError::WrongType(RType::Light, value.rtype()))
+                    Err(HueError::WrongType(RType::Light, value.rtype()))
                 }
             }
         }
 
         impl TryFrom<Resource> for $name {
-            type Error = ApiError;
+            type Error = HueError;
 
             fn try_from(value: Resource) -> Result<Self, Self::Error> {
                 if let Resource::$name(obj) = value {
                     Ok(obj)
                 } else {
-                    Err(ApiError::WrongType(RType::Light, value.rtype()))
+                    Err(HueError::WrongType(RType::Light, value.rtype()))
                 }
             }
         }
@@ -303,12 +303,6 @@ resource_conversion_impl!(ZigbeeConnectivity);
 resource_conversion_impl!(ZigbeeDeviceDiscovery);
 resource_conversion_impl!(Zone);
 
-#[derive(Debug, Serialize, Deserialize)]
-pub struct V2Reply<T> {
-    pub data: Vec<T>,
-    pub errors: Vec<String>,
-}
-
 #[derive(Clone, Debug, Serialize)]
 pub struct V1Reply<'a> {
     prefix: String,
@@ -339,19 +333,19 @@ impl<'a> V1Reply<'a> {
         Self::new(format!("/groups/{id}"))
     }
 
-    pub fn with_light_state_update(self, upd: &ApiLightStateUpdate) -> ApiResult<Self> {
+    pub fn with_light_state_update(self, upd: &ApiLightStateUpdate) -> HueResult<Self> {
         self.add_option("on", upd.on)?
             .add_option("bri", upd.bri)?
             .add_option("xy", upd.xy)?
             .add_option("ct", upd.ct)
     }
 
-    pub fn add<T: Serialize>(mut self, name: &'a str, value: T) -> ApiResult<Self> {
+    pub fn add<T: Serialize>(mut self, name: &'a str, value: T) -> HueResult<Self> {
         self.success.push((name, serde_json::to_value(value)?));
         Ok(self)
     }
 
-    pub fn add_option<T: Serialize>(mut self, name: &'a str, value: Option<T>) -> ApiResult<Self> {
+    pub fn add_option<T: Serialize>(mut self, name: &'a str, value: Option<T>) -> HueResult<Self> {
         if let Some(val) = value {
             self.success.push((name, serde_json::to_value(val)?));
         }

src/hue/api/resource.rs crates/hue/src/api/resource.rs

@@ -4,7 +4,7 @@ use std::hash::{DefaultHasher, Hash, Hasher};
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
-use crate::hue::api::Resource;
+use crate::api::Resource;
 
 #[derive(Copy, Debug, Serialize, Deserialize, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
 #[serde(rename_all = "snake_case")]

src/hue/api/room.rs crates/hue/src/api/room.rs

@@ -3,7 +3,7 @@ use std::ops::{AddAssign, Sub};
 
 use serde::{Deserialize, Serialize};
 
-use crate::hue::api::{RType, ResourceLink};
+use crate::api::{RType, ResourceLink};
 
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
 pub struct RoomMetadata {

src/hue/api/scene.rs crates/hue/src/api/scene.rs

@@ -4,8 +4,8 @@ use chrono::{DateTime, Utc};
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 
-use crate::hue::api::{ColorTemperatureUpdate, ColorUpdate, DimmingUpdate, On, ResourceLink};
-use crate::hue::date_format;
+use crate::api::{ColorTemperatureUpdate, ColorUpdate, DimmingUpdate, On, ResourceLink};
+use crate::date_format;
 
 #[derive(Copy, Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
 #[serde(rename_all = "snake_case")]

src/hue/api/stream.rs crates/hue/src/api/stream.rs

@@ -1,6 +1,6 @@
 use hex::FromHexError;
 
-use crate::error::{ApiError, ApiResult};
+use crate::error::{HueError, HueResult};
 
 pub struct HueStreamKey {
     key: [u8; Self::BYTE_SIZE],
@@ -15,9 +15,9 @@ impl HueStreamKey {
         Self { key }
     }
 
-    pub fn write_to_slice(&self, out: &mut [u8]) -> ApiResult<()> {
+    pub fn write_to_slice(&self, out: &mut [u8]) -> HueResult<()> {
         if out.len() < Self::BYTE_SIZE {
-            return Err(ApiError::FromHexError(FromHexError::InvalidStringLength));
+            return Err(HueError::FromHexError(FromHexError::InvalidStringLength));
         }
         out[..Self::BYTE_SIZE].copy_from_slice(&self.key);
         Ok(())
@@ -28,9 +28,9 @@ impl HueStreamKey {
         hex::encode(self.key)
     }
 
-    pub fn to_hex_slice(&self, out: &mut [u8]) -> ApiResult<()> {
+    pub fn to_hex_slice(&self, out: &mut [u8]) -> HueResult<()> {
         if out.len() < Self::HEX_SIZE {
-            return Err(ApiError::FromHexError(FromHexError::InvalidStringLength));
+            return Err(HueError::FromHexError(FromHexError::InvalidStringLength));
         }
         Ok(hex::encode_to_slice(self.key, &mut out[..Self::HEX_SIZE])?)
     }
@@ -43,12 +43,12 @@ impl AsRef<[u8]> for HueStreamKey {
 }
 
 impl TryFrom<&str> for HueStreamKey {
-    type Error = ApiError;
+    type Error = HueError;
 
     fn try_from(value: &str) -> Result<Self, Self::Error> {
         let mut key = [0u8; 16];
         if value.len() < Self::HEX_SIZE {
-            return Err(ApiError::FromHexError(FromHexError::InvalidStringLength));
+            return Err(HueError::FromHexError(FromHexError::InvalidStringLength));
         }
 
         hex::decode_to_slice(value, &mut key)?;

src/hue/api/stubs.rs crates/hue/src/api/stubs.rs

@@ -5,8 +5,8 @@ use serde::{Deserialize, Deserializer, Serialize};
 use serde_json::Value;
 use uuid::Uuid;
 
-use crate::hue::api::{DeviceArchetype, ResourceLink, SceneMetadata};
-use crate::hue::{best_guess_timezone, date_format};
+use crate::api::{DeviceArchetype, ResourceLink, SceneMetadata};
+use crate::{best_guess_timezone, date_format};
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct Bridge {

src/hue/api/update.rs crates/hue/src/api/update.rs

@@ -1,7 +1,7 @@
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
-use crate::hue::api::{
+use crate::api::{
     DeviceUpdate, EntertainmentConfigurationUpdate, GroupedLightUpdate, LightUpdate, RType,
     RoomUpdate, SceneUpdate,
 };

src/hue/date_format.rs crates/hue/src/date_format.rs

@@ -164,15 +164,15 @@ pub mod legacy_utc_opt {
 mod tests {
     use chrono::{DateTime, TimeZone, Utc};
 
-    use crate::error::ApiResult;
+    use crate::error::HueResult;
 
     fn date() -> (&'static str, DateTime<Utc>) {
         let dt = Utc.with_ymd_and_hms(2014, 7, 8, 9, 10, 11).unwrap();
         ("\"2014-07-08T09:10:11Z\"", dt)
     }
 
     #[test]
-    fn utc_de() -> ApiResult<()> {
+    fn utc_de() -> HueResult<()> {
         let (ds, d1) = date();
 
         let mut deser = serde_json::Deserializer::from_str(ds);
@@ -183,7 +183,7 @@ mod tests {
     }
 
     #[test]
-    fn utc_se() -> ApiResult<()> {
+    fn utc_se() -> HueResult<()> {
         let (s1, dt) = date();
 
         let mut s2 = vec![];

src/hue/devicedb.rs crates/hue/src/devicedb.rs

@@ -1,4 +1,4 @@
-use crate::hue::api::{DeviceArchetype, DeviceProductData};
+use crate::api::{DeviceArchetype, DeviceProductData};
 
 // This file contains discovered product data from multiple sources,
 // including data samples from the community, and various open source or public

crates/hue/src/error.rs

@@ -1,5 +1,7 @@
 use thiserror::Error;
 
+use crate::api::{RType, ResourceLink};
+
 #[derive(Error, Debug)]
 pub enum HueError {
     /* mapped errors */
@@ -9,9 +11,15 @@ pub enum HueError {
     #[error(transparent)]
     IOError(#[from] std::io::Error),
 
+    #[error(transparent)]
+    SerdeJson(#[from] serde_json::Error),
+
     #[error(transparent)]
     TryFromIntError(#[from] std::num::TryFromIntError),
 
+    #[error(transparent)]
+    FromHexError(#[from] hex::FromHexError),
+
     #[error(transparent)]
     PackedStructError(#[from] packed_struct::PackingError),
 
@@ -26,6 +34,24 @@ pub enum HueError {
 
     #[error("Failed to decode Hue Zigbee Update: Unknown flags {0:04x}")]
     HueZigbeeUnknownFlags(u16),
+
+    #[error("State changes not supported for: {0:?}")]
+    UpdateUnsupported(RType),
+
+    #[error("Resource {0} not found")]
+    NotFound(uuid::Uuid),
+
+    #[error("Resource {0} not found")]
+    V1NotFound(u32),
+
+    #[error("Missing auxiliary data resource {0:?}")]
+    AuxNotFound(ResourceLink),
+
+    #[error("Cannot allocate any more {0:?}")]
+    Full(RType),
+
+    #[error("Resource type wrong: expected {0:?} but found {1:?}")]
+    WrongType(RType, RType),
 }
 
 pub type HueResult<T> = Result<T, HueError>;

src/hue/event.rs crates/hue/src/event.rs

@@ -3,12 +3,9 @@ use serde::{Deserialize, Serialize};
 use serde_json::{json, Value};
 use uuid::Uuid;
 
-use crate::{
-    error::ApiResult,
-    hue::api::{self, ResourceLink},
-};
-
-use super::date_format;
+use crate::api::{self, ResourceLink};
+use crate::date_format;
+use crate::error::HueResult;
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
 #[serde(rename_all = "lowercase", tag = "type")]
@@ -38,7 +35,7 @@ impl EventBlock {
         }
     }
 
-    pub fn update(id: &Uuid, id_v1: Option<u32>, data: api::Update) -> ApiResult<Self> {
+    pub fn update(id: &Uuid, id_v1: Option<u32>, data: api::Update) -> HueResult<Self> {
         Ok(Self {
             creationtime: Utc::now(),
             id: Uuid::new_v4(),
@@ -50,7 +47,7 @@ impl EventBlock {
         })
     }
 
-    pub fn delete(link: &ResourceLink) -> ApiResult<Self> {
+    pub fn delete(link: &ResourceLink) -> HueResult<Self> {
         Ok(Self {
             creationtime: Utc::now(),
             id: Uuid::new_v4(),