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
|
use sqlx::{sqlite::Sqlite, SqliteConnection, Transaction};
use crate::error::BoxedError;
use crate::id::Id as BaseId;
use crate::login::app::StoredHash;
pub trait Provider {
fn logins(&mut self) -> Logins;
}
impl<'c> Provider for Transaction<'c, Sqlite> {
fn logins(&mut self) -> Logins {
Logins(self)
}
}
pub struct Logins<'t>(&'t mut SqliteConnection);
// This also implements FromRequestParts (see `src/login/extract/login.rs`). As
// a result, it can be used as an extractor.
#[derive(Clone, Debug, serde::Serialize)]
pub struct Login {
pub id: Id,
pub name: String,
// The omission of the hashed password is deliberate, to minimize the
// chance that it ends up tangled up in debug output or in some other chunk
// of logic elsewhere.
}
impl<'c> Logins<'c> {
pub async fn create(
&mut self,
name: &str,
password_hash: &StoredHash,
) -> Result<Login, BoxedError> {
let id = Id::generate();
let login = sqlx::query_as!(
Login,
r#"
insert or fail
into login (id, name, password_hash)
values ($1, $2, $3)
returning
id as "id: Id",
name
"#,
id,
name,
password_hash,
)
.fetch_one(&mut *self.0)
.await?;
Ok(login)
}
pub async fn by_id(&mut self, id: &Id) -> Result<Login, BoxedError> {
let login = sqlx::query_as!(
Login,
r#"
select
id as "id: Id",
name
from login
where id = $1
"#,
id,
)
.fetch_one(&mut *self.0)
.await?;
Ok(login)
}
/// Retrieves a login by name, plus its stored password hash for
/// verification. If there's no login with the requested name, this will
/// return [None].
pub async fn for_login(
&mut self,
name: &str,
) -> Result<Option<(Login, StoredHash)>, BoxedError> {
let found = sqlx::query!(
r#"
select
id as "id: Id",
name,
password_hash as "password_hash: StoredHash"
from login
where name = $1
"#,
name,
)
.map(|rec| {
(
Login {
id: rec.id,
name: rec.name,
},
rec.password_hash,
)
})
.fetch_optional(&mut *self.0)
.await?;
Ok(found)
}
}
/// Stable identifier for a [Login]. Prefixed with `L`.
#[derive(Clone, Debug, Eq, PartialEq, sqlx::Type, serde::Serialize)]
#[sqlx(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("L")
}
}
impl std::fmt::Display for Id {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
self.0.fmt(f)
}
}
|
