amagi 0.1.1

Rust SDK, CLI, and Web API service skeleton for multi-platform social web adapters.
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

use crate::error::AppError;

/// Ordered JSON value used by Xiaohongshu signing so field order matches the source implementation.
#[derive(Debug, Clone, PartialEq)]
pub enum OrderedJson {
    /// JSON `null`.
    Null,
    /// JSON boolean.
    Bool(bool),
    /// JSON number literal stored in textual form.
    Number(String),
    /// JSON string.
    String(String),
    /// JSON array.
    Array(Vec<OrderedJson>),
    /// JSON object preserving insertion order.
    Object(Vec<(String, OrderedJson)>),
}

impl OrderedJson {
    /// Build an ordered JSON object.
    pub fn object(entries: Vec<(impl Into<String>, OrderedJson)>) -> Self {
        Self::Object(
            entries
                .into_iter()
                .map(|(key, value)| (key.into(), value))
                .collect(),
        )
    }

    /// Build a JSON string value.
    pub fn string(value: impl Into<String>) -> Self {
        Self::String(value.into())
    }

    /// Build a JSON number from a signed integer.
    pub fn int(value: i64) -> Self {
        Self::Number(value.to_string())
    }

    /// Build a JSON number from an unsigned integer.
    pub fn uint(value: u64) -> Self {
        Self::Number(value.to_string())
    }

    /// Build a JSON number from a raw literal string.
    pub fn number_literal(value: impl Into<String>) -> Self {
        Self::Number(value.into())
    }

    /// Return the object entries when this value is an object.
    pub fn as_object(&self) -> Option<&[(String, OrderedJson)]> {
        match self {
            Self::Object(entries) => Some(entries),
            _ => None,
        }
    }

    /// Serialize the ordered JSON value using insertion order.
    pub fn to_json_string(&self) -> Result<String, AppError> {
        match self {
            Self::Null => Ok("null".to_owned()),
            Self::Bool(value) => Ok(if *value { "true" } else { "false" }.to_owned()),
            Self::Number(value) => Ok(value.clone()),
            Self::String(value) => serde_json::to_string(value).map_err(Into::into),
            Self::Array(values) => {
                let mut output = String::from("[");
                for (index, value) in values.iter().enumerate() {
                    if index > 0 {
                        output.push(',');
                    }
                    output.push_str(&value.to_json_string()?);
                }
                output.push(']');
                Ok(output)
            }
            Self::Object(entries) => {
                let mut output = String::from("{");
                for (index, (key, value)) in entries.iter().enumerate() {
                    if index > 0 {
                        output.push(',');
                    }
                    output.push_str(&serde_json::to_string(key)?);
                    output.push(':');
                    output.push_str(&value.to_json_string()?);
                }
                output.push('}');
                Ok(output)
            }
        }
    }

    pub(crate) fn to_query_value(&self) -> Result<String, AppError> {
        match self {
            Self::Null => Ok(String::new()),
            Self::Bool(value) => Ok(if *value { "true" } else { "false" }.to_owned()),
            Self::Number(value) => Ok(value.clone()),
            Self::String(value) => Ok(value.clone()),
            Self::Array(values) => {
                let parts = values
                    .iter()
                    .map(OrderedJson::to_query_value)
                    .collect::<Result<Vec<_>, _>>()?;
                Ok(parts.join(","))
            }
            Self::Object(_) => self.to_json_string(),
        }
    }
}

impl From<&str> for OrderedJson {
    fn from(value: &str) -> Self {
        Self::String(value.to_owned())
    }
}

impl From<String> for OrderedJson {
    fn from(value: String) -> Self {
        Self::String(value)
    }
}

impl From<bool> for OrderedJson {
    fn from(value: bool) -> Self {
        Self::Bool(value)
    }
}

impl From<i64> for OrderedJson {
    fn from(value: i64) -> Self {
        Self::int(value)
    }
}

impl From<u64> for OrderedJson {
    fn from(value: u64) -> Self {
        Self::uint(value)
    }
}