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
|
use std::fmt;
use sqlx::{sqlite::Sqlite, SqliteConnection, Transaction};
use super::channels::Id as ChannelId;
use crate::{
clock::DateTime,
error::BoxedError,
id::Id as BaseId,
login::repo::logins::{Id as LoginId, Login, Logins},
};
pub trait Provider {
fn messages(&mut self) -> Messages;
}
impl<'c> Provider for Transaction<'c, Sqlite> {
fn messages(&mut self) -> Messages {
Messages(self)
}
}
pub struct Messages<'t>(&'t mut SqliteConnection);
#[derive(Clone, Debug, serde::Serialize)]
pub struct BroadcastMessage {
pub id: Id,
pub sender: Login,
pub body: String,
pub sent_at: DateTime,
}
impl<'c> Messages<'c> {
pub async fn create(
&mut self,
sender: &LoginId,
channel: &ChannelId,
body: &str,
sent_at: &DateTime,
) -> Result<BroadcastMessage, BoxedError> {
let id = Id::generate();
let sender = Logins::from(&mut *self.0).by_id(sender).await?;
let message = sqlx::query!(
r#"
insert into message
(id, sender, channel, body, sent_at)
values ($1, $2, $3, $4, $5)
returning
id as "id: Id",
body,
sent_at as "sent_at: DateTime"
"#,
id,
sender.id,
channel,
body,
sent_at,
)
.map(|row| BroadcastMessage {
sender: sender.clone(),
id: row.id,
body: row.body,
sent_at: row.sent_at,
})
.fetch_one(&mut *self.0)
.await?;
Ok(message)
}
pub async fn for_replay(
&mut self,
channel: &ChannelId,
) -> Result<Vec<BroadcastMessage>, BoxedError> {
let messages = sqlx::query!(
r#"
select
message.id as "id: Id",
login.id as "sender_id: LoginId",
login.name as sender_name,
message.body,
message.sent_at as "sent_at: DateTime"
from message
join login on message.sender = login.id
where channel = $1
order by sent_at asc
"#,
channel,
)
.map(|row| BroadcastMessage {
id: row.id,
sender: Login {
id: row.sender_id,
name: row.sender_name,
},
body: row.body,
sent_at: row.sent_at,
})
.fetch_all(&mut *self.0)
.await?;
Ok(messages)
}
}
/// Stable identifier for a [Message]. Prefixed with `M`.
#[derive(Clone, Debug, Eq, Hash, PartialEq, sqlx::Type, serde::Deserialize, serde::Serialize)]
#[sqlx(transparent)]
#[serde(transparent)]
pub struct Id(BaseId);
impl From<BaseId> for Id {
fn from(id: BaseId) -> Self {
Self(id)
}
}
impl Id {
pub fn generate() -> Self {
BaseId::generate("M")
}
}
impl fmt::Display for Id {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
self.0.fmt(f)
}
}
|
