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
125
126
127
128
129
130
131
132
133
134
135
136

mod query;
pub(crate) use query::Query;

mod mutation;
use async_graphql::{EmptySubscription, Schema, SchemaBuilder};
pub(crate) use mutation::Mutation;

use crate::{gql::mutation::ResponseCode, principal::Principal, usecase};

pub(crate) mod object;
pub(crate) mod scalar;

pub(crate) type SyndSchema = Schema<Query, Mutation, EmptySubscription>;

pub(crate) mod handler {
    use async_graphql::http::GraphiQLSource;
    use async_graphql_axum::{GraphQLRequest, GraphQLResponse};
    use axum::{response::IntoResponse, Extension};
    use synd_o11y::audit_span;
    use tokio_metrics::TaskMonitor;
    use tracing::Instrument;

    use crate::{principal::Principal, serve::Context};

    pub(crate) async fn graphiql() -> impl IntoResponse {
        axum::response::Html(GraphiQLSource::build().endpoint("/graphql").finish())
    }

    pub(crate) async fn graphql(
        Extension(Context {
            schema,
            gql_monitor,
        }): Extension<Context>,
        Extension(principal): Extension<Principal>,
        req: GraphQLRequest,
    ) -> GraphQLResponse {
        // Inject authentication
        let req = req.into_inner().data(principal);
        TaskMonitor::instrument(&gql_monitor, schema.execute(req).instrument(audit_span!()))
            .await
            .into()
    }
}

#[must_use]
pub(crate) fn schema_builder() -> SchemaBuilder<Query, Mutation, EmptySubscription> {
    let schema = Schema::build(Query, Mutation, EmptySubscription);

    if cfg!(not(feature = "introspection")) {
        schema
            .disable_introspection()
            .limit_depth(10)
            .limit_complexity(60)
    } else {
        schema.limit_depth(20).limit_complexity(300)
    }
    // disabled
    // schema.extension(Tracing)
}

impl usecase::Context for &async_graphql::Context<'_> {
    fn principal(&self) -> Principal {
        self.data_unchecked::<Principal>().clone()
    }
}

impl<E> async_graphql::ErrorExtensions for usecase::Error<E>
where
    E: std::fmt::Display + Send + Sync + 'static,
{
    fn extend(&self) -> async_graphql::Error {
        async_graphql::Error::new(format!("{self}")).extend_with(|_, ext| match self {
            usecase::Error::Usecase(_) => unreachable!(),
            usecase::Error::Unauthorized(_) => ext.set("code", ResponseCode::Unauthorized),
            usecase::Error::Repository(_) => ext.set("code", ResponseCode::InternalError),
        })
    }
}

impl async_graphql::ErrorExtensions for usecase::FetchEntriesError {
    fn extend(&self) -> async_graphql::Error {
        async_graphql::Error::new(format!("{self}"))
            .extend_with(|_, ext| ext.set("code", ResponseCode::InternalError))
    }
}

impl async_graphql::ErrorExtensions for usecase::FetchSubscribedFeedsError {
    fn extend(&self) -> async_graphql::Error {
        async_graphql::Error::new(format!("{self}"))
            .extend_with(|_, ext| ext.set("code", ResponseCode::InternalError))
    }
}

macro_rules! run_usecase {
    ($usecase:ty, $cx:expr, $input:expr,$err_handle:expr) => {{
        let runtime = $cx.data_unchecked::<crate::usecase::Runtime>();
        let err_handle = $err_handle;

        match runtime.run::<$usecase, _, _>($cx, $input).await {
            Ok(output) => Ok(output.into()),
            Err($crate::usecase::Error::Usecase(uc_err)) => err_handle(uc_err),
            Err(err) => Err(async_graphql::ErrorExtensions::extend(&err)),
        }
    }};
}

pub(super) use run_usecase;

#[cfg(test)]
mod tests {
    use async_graphql::ErrorExtensions;

    use crate::usecase::authorize::Unauthorized;

    use super::*;

    #[test]
    fn usecase_error_impl_gql_error() {
        insta::assert_yaml_snapshot!(
            "unauthorized",
            usecase::Error::<String>::Unauthorized(Unauthorized).extend()
        );
        insta::assert_yaml_snapshot!(
            "repository",
            usecase::Error::<String>::Repository(crate::repository::RepositoryError::Internal(
                anyhow::anyhow!("error")
            ))
            .extend()
        );
        insta::assert_yaml_snapshot!("fetch_entries", usecase::FetchEntriesError {}.extend());
        insta::assert_yaml_snapshot!(
            "fetch_subscribed_feeds",
            usecase::FetchSubscribedFeedsError {}.extend()
        );
    }
}