synd-api 0.2.6

syndicationd backend api
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

use async_graphql::{InputObject, Object, Union};
use synd_feed::{
    feed::service::FetchFeedError,
    types::{Category, FeedUrl, Requirement},
};

use crate::{
    gql::{
        mutation::ResponseStatus,
        object::{self, Feed},
    },
    usecase::{self, SubscribeFeedError as UsecaseSubscribeFeedError},
};

#[derive(InputObject, Debug)]
pub(crate) struct SubscribeFeedInput {
    /// Feed url to subscribe
    pub url: FeedUrl,
    /// Requirement level for feed
    pub requirement: Option<Requirement>,
    /// Feed category
    pub category: Option<Category<'static>>,
}

impl From<SubscribeFeedInput> for usecase::SubscribeFeedInput {
    fn from(value: SubscribeFeedInput) -> Self {
        usecase::SubscribeFeedInput {
            url: value.url,
            requirement: value.requirement,
            category: value.category,
        }
    }
}

#[allow(clippy::large_enum_variant)]
#[derive(Union)]
pub(crate) enum SubscribeFeedResponse {
    Success(SubscribeFeedSuccess),
    Error(SubscribeFeedError),
}

pub(crate) struct SubscribeFeedSuccess {
    pub status: ResponseStatus,
    /// Subscribed feed
    pub feed: object::Feed,
}

#[Object]
impl SubscribeFeedSuccess {
    pub async fn status(&self) -> ResponseStatus {
        self.status.clone()
    }

    pub async fn feed(&self) -> &object::Feed {
        &self.feed
    }
}

pub(crate) struct SubscribeFeedError {
    pub status: ResponseStatus,
    pub message: String,
}

#[Object]
impl SubscribeFeedError {
    pub async fn status(&self) -> ResponseStatus {
        self.status.clone()
    }

    /// Error message
    pub async fn message(&self) -> String {
        self.message.clone()
    }
}

impl From<usecase::Output<usecase::SubscribeFeedOutput>> for SubscribeFeedResponse {
    fn from(output: usecase::Output<usecase::SubscribeFeedOutput>) -> Self {
        SubscribeFeedResponse::Success(SubscribeFeedSuccess {
            status: ResponseStatus::ok(),
            feed: Feed::from(output.output.feed),
        })
    }
}

impl From<UsecaseSubscribeFeedError> for SubscribeFeedResponse {
    fn from(err: UsecaseSubscribeFeedError) -> Self {
        SubscribeFeedResponse::Error(err.into())
    }
}

impl From<UsecaseSubscribeFeedError> for SubscribeFeedError {
    fn from(err: UsecaseSubscribeFeedError) -> Self {
        match err {
            UsecaseSubscribeFeedError::FetchFeed(fetch_err) => match fetch_err {
                FetchFeedError::InvalidFeed(kind) => Self {
                    status: ResponseStatus::invalid_feed_url(),
                    message: format!("{kind}"),
                },
                FetchFeedError::Fetch(request_err) => Self {
                    status: ResponseStatus::feed_unavailable(),
                    message: format!("feed unavailable: {request_err}"),
                },
                fetch_err => Self {
                    status: ResponseStatus::internal(),
                    message: format!("{fetch_err}"),
                },
            },
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn internal_error() {
        let r = SubscribeFeedError::from(UsecaseSubscribeFeedError::FetchFeed(
            FetchFeedError::Other(anyhow::anyhow!("error")),
        ));

        assert_eq!(r.status, ResponseStatus::internal());
    }
}