rs-auth-postgres 0.1.0

Postgres persistence and migrations for rs-auth.
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

use async_trait::async_trait;
use sqlx::Row;

use rs_auth_core::error::AuthError;
use rs_auth_core::store::VerificationStore;
use rs_auth_core::types::{NewVerification, Verification};

use crate::db::AuthDb;

#[async_trait]
impl VerificationStore for AuthDb {
    async fn create_verification(
        &self,
        verification: NewVerification,
    ) -> Result<Verification, AuthError> {
        sqlx::query(
            r#"
            INSERT INTO verifications (identifier, token_hash, expires_at)
            VALUES ($1, $2, $3)
            RETURNING id, identifier, token_hash, expires_at, created_at, updated_at
            "#,
        )
        .bind(verification.identifier)
        .bind(verification.token_hash)
        .bind(verification.expires_at)
        .fetch_one(&self.pool)
        .await
        .map(|row| Verification {
            id: row.get("id"),
            identifier: row.get("identifier"),
            token_hash: row.get("token_hash"),
            expires_at: row.get("expires_at"),
            created_at: row.get("created_at"),
            updated_at: row.get("updated_at"),
        })
        .map_err(|error| AuthError::Store(error.to_string()))
    }

    async fn find_by_identifier(
        &self,
        identifier: &str,
    ) -> Result<Option<Verification>, AuthError> {
        sqlx::query(
            r#"
            SELECT id, identifier, token_hash, expires_at, created_at, updated_at
            FROM verifications
            WHERE identifier = $1
            "#,
        )
        .bind(identifier)
        .fetch_optional(&self.pool)
        .await
        .map(|row| {
            row.map(|row| Verification {
                id: row.get("id"),
                identifier: row.get("identifier"),
                token_hash: row.get("token_hash"),
                expires_at: row.get("expires_at"),
                created_at: row.get("created_at"),
                updated_at: row.get("updated_at"),
            })
        })
        .map_err(|error| AuthError::Store(error.to_string()))
    }

    async fn find_by_token_hash(
        &self,
        token_hash: &str,
    ) -> Result<Option<Verification>, AuthError> {
        sqlx::query(
            r#"
            SELECT id, identifier, token_hash, expires_at, created_at, updated_at
            FROM verifications
            WHERE token_hash = $1
            "#,
        )
        .bind(token_hash)
        .fetch_optional(&self.pool)
        .await
        .map(|row| {
            row.map(|row| Verification {
                id: row.get("id"),
                identifier: row.get("identifier"),
                token_hash: row.get("token_hash"),
                expires_at: row.get("expires_at"),
                created_at: row.get("created_at"),
                updated_at: row.get("updated_at"),
            })
        })
        .map_err(|error| AuthError::Store(error.to_string()))
    }

    async fn delete_verification(&self, id: i64) -> Result<(), AuthError> {
        sqlx::query(r#"DELETE FROM verifications WHERE id = $1"#)
            .bind(id)
            .execute(&self.pool)
            .await
            .map(|_| ())
            .map_err(|error| AuthError::Store(error.to_string()))
    }

    async fn delete_by_identifier(&self, identifier: &str) -> Result<(), AuthError> {
        sqlx::query(r#"DELETE FROM verifications WHERE identifier = $1"#)
            .bind(identifier)
            .execute(&self.pool)
            .await
            .map(|_| ())
            .map_err(|error| AuthError::Store(error.to_string()))
    }

    async fn delete_expired(&self) -> Result<u64, AuthError> {
        sqlx::query(r#"DELETE FROM verifications WHERE expires_at < now()"#)
            .execute(&self.pool)
            .await
            .map(|result| result.rows_affected())
            .map_err(|error| AuthError::Store(error.to_string()))
    }
}