nodeinfo-upub 0.0.3

de-/serialize nodeinfo json structs (upub fork)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

use serde::{Deserialize, Serialize};
use serde_json::{Map, Value};

/// Node metadata for version detection only used for deserialization.
#[derive(Debug, Deserialize)]
pub(crate) struct NodeVersion<'a> {
  pub(crate) version: &'a str,
}

pub type NodeInfo<'a> = NodeInfoInternal<&'a str>;
pub type NodeInfoOwned = NodeInfoInternal<String>;

/// Node metadata about a server running in the fediverse.
#[derive(Debug, PartialEq, Serialize, Deserialize)]
pub struct NodeInfoInternal<T> {
  pub version: T,
  pub software: Software<T>,
  #[serde(default)]
  pub protocols: Vec<T>,
  #[serde(default)]
  pub services: Services<T>,
  #[serde(rename = "openRegistrations", default)]
  pub open_registrations: bool,
  #[serde(default)]
  pub usage: Usage,
  #[serde(default)]
  pub metadata: Map<String, Value>,
}

/// Node legacy metadata about a server running in the federation, only used for deserialization.
#[derive(Debug, PartialEq, Deserialize)]
pub struct LegacyNodeInfo<'a> {
  version: &'a str,
  software: Software<&'a str>,
  #[serde(default)]
  services: Services<&'a str>,
  #[serde(default)]
  protocols: Services<&'a str>,
  #[serde(rename = "openRegistrations", default)]
  open_registrations: bool,
  #[serde(default)]
  usage: Usage,
  #[serde(default)]
  metadata: Map<String, Value>,
}

/// Software contains infos about software running on the node.
#[derive(Debug, PartialEq, Serialize, Deserialize)]
pub struct Software<T> {
  pub name: T,
  pub version: Option<T>,
  pub repository: Option<T>,
  pub homepage: Option<T>,
}

/// Services tell about third party sites the node can connect to or interact with.
#[derive(Debug, PartialEq, Default, Serialize, Deserialize)]
pub struct Services<T> {
  pub inbound: Vec<T>,
  pub outbound: Vec<T>,
}

/// Usage statistics for the node
#[derive(Debug, PartialEq, Default, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Usage {
  pub users: Option<Users>,
  pub local_posts: Option<i64>,
  pub local_comments: Option<i64>,
}

// UsersUsage are statistics about the users of the node.
#[derive(Debug, PartialEq, Default, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Users {
  pub total: Option<i64>,
  pub active_halfyear: Option<i64>,
  pub active_month: Option<i64>,
}

impl<'a> Software<&'a str> {
  fn to_owned(&self) -> Software<String> {
    Software {
      name: self.name.to_string(),
      version: self.version.map(ToString::to_string),
      repository: self.repository.map(ToString::to_string),
      homepage: self.homepage.map(ToString::to_string),
    }
  }
}

impl<'a> Services<&'a str> {
  fn to_owned(&self) -> Services<String> {
    Services {
      inbound: self.inbound.iter().map(ToString::to_string).collect(),
      outbound: self.outbound.iter().map(ToString::to_string).collect(),
    }
  }
}

impl NodeInfo<'_> {
  /// Converts all internal `&str`s into `String`s.
  pub fn to_owned(&self) -> NodeInfoOwned {
    NodeInfoOwned {
      version: self.version.to_string(),
      software: self.software.to_owned(),
      protocols: self.protocols.iter().map(ToString::to_string).collect(),
      services: self.services.to_owned(),
      open_registrations: self.open_registrations,
      usage: self.usage.clone(),
      metadata: self.metadata.clone(),
    }
  }
}

impl<'a> From<LegacyNodeInfo<'a>> for NodeInfo<'a> {
  fn from(other: LegacyNodeInfo<'a>) -> Self {
    let mut combined_protocols: Vec<&'a str> = other
      .protocols
      .inbound
      .into_iter()
      .chain(other.protocols.outbound)
      .collect();
    combined_protocols.sort();
    combined_protocols.dedup();

    NodeInfo {
      version: other.version,
      software: other.software,
      services: other.services,
      protocols: combined_protocols,
      open_registrations: other.open_registrations,
      usage: other.usage,
      metadata: other.metadata,
    }
  }
}

impl<'a> From<LegacyNodeInfo<'a>> for NodeInfoOwned {
  fn from(value: LegacyNodeInfo<'a>) -> Self {
    NodeInfo::from(value).to_owned()
  }
}