refactor: Debug derive cleanup

Signed-off-by: Nick Gerakines <[e-mail]>

Cargo.toml

···
 
 [workspace.package]
 edition = "2024"
-rust-version = "1.87"
+rust-version = "1.89"
 repository = "https://tangled.sh/@smokesignal.events/atproto-identity-rs"
 authors = ["Nick Gerakines <[e-mail]>"]
 license = "MIT"

crates/atproto-oauth/src/encoding.rs

···
 /// Trait for converting types to base64-encoded JSON.
 pub trait ToBase64 {
     /// Convert the type to a base64-encoded JSON string.
-    fn to_base64(&self) -> Result<Cow<str>>;
+    fn to_base64(&self) -> Result<Cow<'_, str>>;
 }
 
 impl<T: Serialize> ToBase64 for T {
-    fn to_base64(&self) -> Result<Cow<str>> {
+    fn to_base64(&self) -> Result<Cow<'_, str>> {
         let json_bytes = serde_json::to_vec(&self)?;
         let encoded_json_bytes = general_purpose::URL_SAFE_NO_PAD.encode(json_bytes);
         Ok(Cow::Owned(encoded_json_bytes))

crates/atproto-record/src/lexicon/com_atproto_repo.rs

···
 /// // Use TypedStrongRef for automatic $type field handling
 /// let typed_ref = TypedStrongRef::new(strong_ref);
 /// ```
-#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
+#[derive(Serialize, Deserialize, PartialEq, Clone)]
+#[cfg_attr(debug_assertions, derive(Debug))]
 pub struct StrongRef {
     /// AT URI pointing to a specific record
     /// Format: at://[did]/[collection]/[rkey]

crates/atproto-record/src/lexicon/community_lexicon_attestation.rs

···
 /// // Referenced signature
 /// let reference = SignatureOrRef::Reference(typed_strong_ref);
 /// ```
-#[derive(Debug, Deserialize, Serialize, Clone, PartialEq)]
+#[derive(Deserialize, Serialize, Clone, PartialEq)]
+#[cfg_attr(debug_assertions, derive(Debug))]
 #[serde(untagged)]
 pub enum SignatureOrRef {
     /// A reference to a signature stored elsewhere
···
 ///     extra: HashMap::new(),
 /// };
 /// ```
-#[derive(Debug, Deserialize, Serialize, Clone, PartialEq)]
+#[derive(Deserialize, Serialize, Clone, PartialEq)]
+#[cfg_attr(debug_assertions, derive(Debug))]
 pub struct Signature {
     /// DID of the entity that created this signature
     pub issuer: String,

crates/atproto-record/src/lexicon/community_lexicon_badge.rs

···
 ///
 /// let typed_badge = TypedDefinition::new(badge);
 /// ```
-#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
+#[derive(Serialize, Deserialize, Clone, PartialEq)]
+#[cfg_attr(debug_assertions, derive(Debug))]
 pub struct Definition {
     /// Name of the badge
     pub name: String,
···
 }
 
 /// Type alias for Definition with automatic $type field handling
+#[allow(dead_code)]
 pub type TypedDefinition = TypedLexicon<Definition>;
 
 /// Badge award structure.
···
 ///
 /// let typed_award = TypedAward::new(award);
 /// ```
-#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
+#[derive(Serialize, Deserialize, Clone, PartialEq)]
+#[cfg_attr(debug_assertions, derive(Debug))]
 pub struct Award {
     /// Reference to the badge definition being awarded
     pub badge: TypedStrongRef,
···
 }
 
 /// Type alias for Award with automatic $type field handling
+#[allow(dead_code)]
 pub type TypedAward = TypedLexicon<Award>;
 
 #[cfg(test)]

crates/atproto-record/src/lexicon/community_lexicon_calendar_event.rs

···
 
 use crate::datetime::format as datetime_format;
 use crate::datetime::optional_format as optional_datetime_format;
+use crate::lexicon::TypedBlob;
 use crate::lexicon::community::lexicon::location::Locations;
-use crate::lexicon::{Blob, TypedBlob};
 use crate::typed::{LexiconType, TypedLexicon};
 
 /// The namespace identifier for events
···
 /// Event status enumeration.
 ///
 /// Represents the current status of a calendar event.
-#[derive(Debug, Serialize, Deserialize, PartialEq, Clone, Default)]
+#[derive(Serialize, Deserialize, PartialEq, Clone, Default)]
+#[cfg_attr(debug_assertions, derive(Debug))]
 pub enum Status {
     /// Event is scheduled and confirmed
     #[default]
···
 /// Event mode enumeration.
 ///
 /// Represents how attendees can participate in the event.
-#[derive(Debug, Serialize, Deserialize, PartialEq, Clone, Default)]
+#[derive(Serialize, Deserialize, PartialEq, Clone, Default)]
+#[cfg_attr(debug_assertions, derive(Debug))]
 pub enum Mode {
     /// In-person attendance only
     #[default]
···
 ///
 /// Represents a URI with an optional human-readable name.
 /// Used for linking to external resources related to an event.
-#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
+#[derive(Serialize, Deserialize, PartialEq, Clone)]
+#[cfg_attr(debug_assertions, derive(Debug))]
 pub struct NamedUri {
     /// The URI/URL
     pub uri: String,
···
 ///
 /// Similar to NamedUri but kept as a separate type for semantic clarity
 /// and type safety when dealing with event-specific links.
-#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
+#[derive(Serialize, Deserialize, PartialEq, Clone)]
+#[cfg_attr(debug_assertions, derive(Debug))]
 pub struct EventLink {
     /// The URI/URL for the event link
     pub uri: String,
···
 /// Aspect ratio for media content.
 ///
 /// Represents the width-to-height ratio of visual media.
-#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
+#[derive(Serialize, Deserialize, PartialEq, Clone)]
+#[cfg_attr(debug_assertions, derive(Debug))]
 pub struct AspectRatio {
     /// Width component of the ratio
     pub width: u64,
···
 /// Media structure for event-related visual content.
 ///
 /// Represents images, videos, or other media associated with an event.
-#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
+#[derive(Serialize, Deserialize, PartialEq, Clone)]
+#[cfg_attr(debug_assertions, derive(Debug))]
 pub struct Media {
     /// The media content as a blob reference
     pub content: TypedBlob,
···
 ///
 /// let typed_event = TypedEvent::new(event);
 /// ```
-#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
+#[derive(Serialize, Deserialize, PartialEq, Clone)]
+#[cfg_attr(debug_assertions, derive(Debug))]
 pub struct Event {
     /// Name/title of the event
     pub name: String,
···
 
 #[cfg(test)]
 mod tests {
+    use crate::lexicon::Blob;
+
     use super::*;
     use anyhow::Result;
 

crates/atproto-record/src/lexicon/community_lexicon_calendar_rsvp.rs

···
 /// RSVP status enumeration.
 ///
 /// Represents the response status for an event invitation.
-#[derive(Debug, Serialize, Deserialize, PartialEq, Clone, Default)]
+#[derive(Serialize, Deserialize, PartialEq, Clone, Default)]
+#[cfg_attr(debug_assertions, derive(Debug))]
 pub enum RsvpStatus {
     /// Attendee is planning to attend
     #[default]
···
 /// // Use TypedRsvp for automatic $type field handling
 /// let typed_rsvp = TypedRsvp::new(rsvp);
 /// ```
-#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
+#[derive(Serialize, Deserialize, PartialEq, Clone)]
+#[cfg_attr(debug_assertions, derive(Debug))]
 pub struct Rsvp {
     /// Reference to the event being responded to
     pub subject: StrongRef,

crates/atproto-record/src/lexicon/community_lexicon_location.rs

···
 /// };
 /// let location = LocationOrRef::InlineAddress(TypedAddress::new(address));
 /// ```
-#[derive(Debug, Deserialize, Serialize, Clone, PartialEq)]
+#[derive(Deserialize, Serialize, Clone, PartialEq)]
+#[cfg_attr(debug_assertions, derive(Debug))]
 #[serde(untagged)]
 pub enum LocationOrRef {
     /// A reference to a location stored elsewhere
···
 ///     name: Some("Tech Hub Building".to_string()),
 /// };
 /// ```
-#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
+#[derive(Serialize, Deserialize, PartialEq, Clone)]
+#[cfg_attr(debug_assertions, derive(Debug))]
 pub struct Address {
     /// Country name (required)
     pub country: String,
···
 ///     name: Some("San Francisco".to_string()),
 /// };
 /// ```
-#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
+#[derive(Serialize, Deserialize, PartialEq, Clone)]
+#[cfg_attr(debug_assertions, derive(Debug))]
 pub struct Geo {
     /// Latitude coordinate as a string
     pub latitude: String,
···
 ///     name: Some("Empire State Building".to_string()),
 /// };
 /// ```
-#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
+#[derive(Serialize, Deserialize, PartialEq, Clone)]
+#[cfg_attr(debug_assertions, derive(Debug))]
 pub struct Fsq {
     /// Foursquare place identifier
     pub fsq_place_id: String,
···
 ///     name: Some("Downtown Area".to_string()),
 /// };
 /// ```
-#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
+#[derive(Serialize, Deserialize, PartialEq, Clone)]
+#[cfg_attr(debug_assertions, derive(Debug))]
 pub struct Hthree {
     /// H3 hexagon identifier
     pub value: String,

crates/atproto-record/src/lexicon/primatives.rs

···
 /// // Use TypedBlob for automatic $type field handling
 /// let typed_blob = TypedBlob::new(blob);
 /// ```
-#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
+#[derive(Serialize, Deserialize, PartialEq, Clone)]
+#[cfg_attr(debug_assertions, derive(Debug))]
 pub struct Blob {
     /// Link to the blob content via CID
     #[serde(rename = "ref")]
···
 ///
 /// Represents a content-addressed link using a CID (Content Identifier).
 /// This is used to reference immutable content in the AT Protocol network.
-#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
+#[derive(Serialize, Deserialize, PartialEq, Clone)]
+#[cfg_attr(debug_assertions, derive(Debug))]
 pub struct Link {
     /// The CID (Content Identifier) as a string
     #[serde(rename = "$link")]
···
 /// };
 /// // Serializes to: {"$bytes": "c2lnbmF0dXJlIGRhdGE="}
 /// ```
-#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
+#[derive(Serialize, Deserialize, PartialEq, Clone)]
+#[cfg_attr(debug_assertions, derive(Debug))]
 pub struct Bytes {
     /// The raw bytes, serialized as base64 in JSON
     #[serde(rename = "$bytes", with = "bytes_format")]