miniorm 0.4.1

a *very* simple ORM built on top of sqlx
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

use crate::{traits::crud::Crud, WithId};
use axum::{
    extract::{Path, State},
    http::StatusCode,
    response::IntoResponse,
    routing::{delete, get, post, put},
    Json, Router,
};
use serde::{Deserialize, Serialize};
use std::marker::PhantomData;

pub(crate) struct Handler<E, S> {
    entity: PhantomData<E>,
    store: S,
}

impl<E, S> Handler<E, S> {
    pub(crate) fn new(store: S) -> Self {
        let entity = PhantomData;
        Handler { entity, store }
    }
}

impl<E, S> Handler<E, S>
where
    S: Crud<E> + Sync + Send + Clone + 'static,
    E: Send + 'static,
    E: Serialize + for<'de> Deserialize<'de>,
{
    fn to_status_code(err: sqlx::Error) -> StatusCode {
        match err {
            sqlx::Error::RowNotFound => StatusCode::NOT_FOUND,
            _ => StatusCode::INTERNAL_SERVER_ERROR,
        }
    }

    pub(crate) async fn create(
        State(store): State<S>,
        Json(payload): Json<E>,
    ) -> Result<impl IntoResponse, StatusCode> {
        store
            .create(payload)
            .await
            .map_err(Self::to_status_code)
            .map(Json)
    }

    pub(crate) async fn read(
        Path(id): Path<i64>,
        State(store): State<S>,
    ) -> Result<impl IntoResponse, StatusCode> {
        store.read(id).await.map_err(Self::to_status_code).map(Json)
    }

    pub(crate) async fn list(State(store): State<S>) -> Result<impl IntoResponse, StatusCode> {
        store.list().await.map_err(Self::to_status_code).map(Json)
    }

    pub(crate) async fn update(
        Path(id): Path<i64>,
        State(store): State<S>,
        Json(payload): Json<E>,
    ) -> Result<impl IntoResponse, StatusCode> {
        let payload = WithId::new(payload, id);
        store
            .update(payload)
            .await
            .map_err(Self::to_status_code)
            .map(Json)
    }

    pub(crate) async fn update_with_id(
        State(store): State<S>,
        Json(payload): Json<WithId<E>>,
    ) -> Result<impl IntoResponse, StatusCode> {
        store
            .update(payload)
            .await
            .map_err(Self::to_status_code)
            .map(Json)
    }

    pub(crate) async fn delete(
        Path(id): Path<i64>,
        State(store): State<S>,
    ) -> Result<impl IntoResponse, StatusCode> {
        store.delete(id).await.map_err(Self::to_status_code)
    }

    pub(crate) async fn delete_all(
        State(store): State<S>,
    ) -> Result<impl IntoResponse, StatusCode> {
        store
            .delete_all()
            .await
            .map_err(Self::to_status_code)
            .map(|_| ())
    }

    pub(crate) fn into_axum_router<R>(self) -> Router<R> {
        Router::new()
            .route("/", get(Self::list))
            .route("/", post(Self::create))
            .route("/", delete(Self::delete_all))
            .route("/", put(Self::update_with_id))
            .route("/:id", delete(Self::delete))
            .route("/:id", get(Self::read))
            .route("/:id", put(Self::update))
            .with_state(self.store)
    }
}