tailwag_orm 0.1.0

An ORM for building Postgres schemas and data access with a Manager pattern, backed by 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

use reqwest::{self};
use serde::{Deserialize, Serialize};
use std::marker::PhantomData;
use uuid::Uuid;

use crate::queries::filterable_types::Filterable;

use super::traits::DataProvider;

/// Creates a DataProvider that will fetch the given type from the provided REST endpoint.
/// Makes specific assumptions about the way the REST endpoint works, and implements this for the base-case
#[derive(Clone)]
pub struct RestApiDataProvider<T>
where
    T: Serialize + for<'d> Deserialize<'d>,
{
    endpoint: String,
    http_client: reqwest::Client,
    _t: PhantomData<T>,
}

impl<T> RestApiDataProvider<T>
where
    T: Serialize + for<'d> Deserialize<'d>,
{
    pub fn from_endpoint(url: String) -> Self {
        let client = reqwest::Client::new();
        Self {
            endpoint: url,
            http_client: client,
            _t: PhantomData,
        }
    }
}

pub trait Id {
    fn id(&self) -> &Uuid;
}

impl<T> DataProvider<T> for RestApiDataProvider<T>
where
    T: Serialize + for<'d> Deserialize<'d> + Id + Default + Clone + Send + Sync + Filterable,
{
    // TODO: Figure out how to map CreateRequest
    type CreateRequest = T;
    type Error = crate::Error;

    async fn all(&self) -> Result<impl Iterator<Item = T>, Self::Error> {
        Ok(self
            .http_client
            .get(&self.endpoint)
            .send()
            .await
            .unwrap()
            .json::<Vec<T>>()
            .await
            .unwrap()
            .into_iter())
    }

    async fn get(
        &self,
        _predicate: impl Fn(T::FilterType) -> crate::queries::Filter,
    ) -> Result<Option<T>, Self::Error> {
        // let url = format!("{}/{}", &self.endpoint, &id);
        // let response = self.http_client.get(&url).send().await.unwrap();
        // // if response.status() == StatusCode::NOT_FOUND {
        // //     None
        // // } else {
        // // }
        // Ok(response.json::<Option<T>>().await?)
        todo!()
    }

    async fn create(
        &self,
        item: Self::CreateRequest,
    ) -> Result<T, Self::Error> {
        let _response = self.http_client.post(&self.endpoint).json(&item).send().await?;
        Ok(item)
    }

    async fn delete(
        &self,
        item: T,
    ) -> Result<(), Self::Error> {
        // let url = format!("{}/{}", &self.endpoint, &item.id());
        let url = &self.endpoint;
        let _response = self.http_client.delete(url).json(&item).send().await.unwrap();
        Ok(())
    }

    async fn update(
        &self,
        item: &T,
    ) -> Result<(), Self::Error> {
        // let url = format!("{}/{}", &self.endpoint, &item.id());
        let url = &self.endpoint;
        let _response = self.http_client.patch(url).json(item).send().await.unwrap();
        Ok(())
    }
}