apub-core 0.2.0

Utilities for building activitypub servers
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
144
145
146
147
148
149
150
151
152
153
154
155
156
157

//! Traits describing the delivery of objects to remote servers

use std::{rc::Rc, sync::Arc};
use url::Url;

use crate::session::Session;

/// Describes sending an activity to a server
///
/// When implementing this trait, things like HTTP Signatures and HTTP Digests should be considered
///
/// ```rust
/// use apub_core::{deliver::Deliver, session::Session};
/// use url::Url;
///
/// pub struct MyClient {
///     inner: reqwest::Client,
/// }
///
/// #[async_trait::async_trait(?Send)]
/// impl Deliver for MyClient {
///     type Error = reqwest::Error;
///
///     async fn deliver<T: serde::ser::Serialize, S: Session>(&self, inbox: &Url, activity: &T, _: S) -> Result<(), Self::Error> {
///         self.inner.post(inbox.as_str()).json(activity).send().await?;
///         Ok(())
///     }
/// }
/// ```
#[async_trait::async_trait(?Send)]
pub trait Deliver {
    /// Errors produced by the client
    type Error: std::fmt::Display + 'static;

    /// Deliver the activity to the inbox
    async fn deliver<T: serde::ser::Serialize, S: Session>(
        &self,
        inbox: &Url,
        activity: &T,
        session: S,
    ) -> Result<(), Self::Error>;
}

/// The inverse of [`Deliver`], allows for `item.deliver(&client)` syntax
///
/// ```rust
/// use apub_core::deliver::Deliverable;
/// use url::Url;
///
/// #[derive(serde::Deserialize, serde::Serialize)]
/// pub struct MyActivity {
///     id: Url,
///     // etc...
/// }
///
/// impl Deliverable for MyActivity {}
/// ```
#[async_trait::async_trait(?Send)]
pub trait Deliverable: serde::ser::Serialize {
    /// Deliver the activity to the inbox
    async fn deliver<D: Deliver, S: Session>(
        &self,
        inbox: &Url,
        client: &D,
        session: S,
    ) -> Result<(), D::Error>
    where
        Self: Sized,
    {
        client.deliver(inbox, self, session).await
    }
}

#[async_trait::async_trait(?Send)]
impl<'a, D> Deliver for &'a D
where
    D: Deliver,
{
    type Error = D::Error;

    async fn deliver<T: serde::ser::Serialize, S: Session>(
        &self,
        inbox: &Url,
        activity: &T,
        session: S,
    ) -> Result<(), Self::Error> {
        D::deliver(self, inbox, activity, session).await
    }
}

#[async_trait::async_trait(?Send)]
impl<'a, D> Deliver for &'a mut D
where
    D: Deliver,
{
    type Error = D::Error;

    async fn deliver<T: serde::ser::Serialize, S: Session>(
        &self,
        inbox: &Url,
        activity: &T,
        session: S,
    ) -> Result<(), Self::Error> {
        D::deliver(self, inbox, activity, session).await
    }
}

#[async_trait::async_trait(?Send)]
impl<D> Deliver for Box<D>
where
    D: Deliver,
{
    type Error = D::Error;

    async fn deliver<T: serde::ser::Serialize, S: Session>(
        &self,
        inbox: &Url,
        activity: &T,
        session: S,
    ) -> Result<(), Self::Error> {
        D::deliver(self, inbox, activity, session).await
    }
}

#[async_trait::async_trait(?Send)]
impl<D> Deliver for Rc<D>
where
    D: Deliver,
{
    type Error = D::Error;

    async fn deliver<T: serde::ser::Serialize, S: Session>(
        &self,
        inbox: &Url,
        activity: &T,
        session: S,
    ) -> Result<(), Self::Error> {
        D::deliver(self, inbox, activity, session).await
    }
}

#[async_trait::async_trait(?Send)]
impl<D> Deliver for Arc<D>
where
    D: Deliver,
{
    type Error = D::Error;

    async fn deliver<T: serde::ser::Serialize, S: Session>(
        &self,
        inbox: &Url,
        activity: &T,
        session: S,
    ) -> Result<(), Self::Error> {
        D::deliver(self, inbox, activity, session).await
    }
}