saas-rs-sdk 0.6.2

The SaaS RS SDK
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

use crate::models::model_from_message;
use crate::storage::Error;
use crate::storage::config_store::{ConfigStore, FindOptions};
use pbbson::prost::Message;
use serde::{Deserialize, Serialize};
use std::{fmt::Debug, str::FromStr, sync::Arc};
use tonic::Status;

pub struct ConfigDao<B: Clone + Debug + FromStr + ToString> {
    config_store: Arc<dyn ConfigStore<B>>,
}

impl<B: Clone + Debug + FromStr + ToString> ConfigDao<B> {
    pub fn new(config_store: Arc<dyn ConfigStore<B>>) -> Self {
        Self { config_store }
    }

    pub fn config_store(&self) -> Arc<dyn ConfigStore<B>> {
        self.config_store.clone()
    }

    pub async fn create<T: Message + Serialize + for<'a> Deserialize<'a> + Clone + Default>(
        &self,
        bucket: B,
        model: &T,
    ) -> Result<T, Status> {
        self.config_store
            .create(bucket.clone(), model_from_message(model)?)
            .await
            .map_err(|e| {
                log::error!(bucket:?, err:? = e; "Failed creating record");
                to_status(e)
            })?
            .try_into()
            .map_err(|e| {
                log::error!(bucket:?, err:? = e; "Failed converting created model back into a message");
                Status::internal(e.to_string())
            })
    }

    pub async fn delete(&self, bucket: B, id: &str, by_account_id: Option<String>) -> Result<(), Status> {
        self.config_store
            .delete(bucket.clone(), id, by_account_id)
            .await
            .map_err(|e| {
                log::error!(bucket:?, err:? = e; "Failed deleting record");
                e
            })?;
        Ok(())
    }

    pub async fn find<T: Message + Serialize + for<'a> Deserialize<'a> + Clone + Default>(
        &self,
        bucket: B,
        id: &str,
    ) -> Result<T, Status> {
        self.config_store
            .find(bucket.clone(), id)
            .await
            .map_err(|e| {
                log::error!(bucket:?, id, err:? = e; "Failed finding record");
                to_status(e)
            })?
            .try_into()
            .map_err(|e| {
                log::error!(bucket:?, err:? = e; "Failed converting found model into a message");
                Status::internal(e.to_string())
            })
    }

    pub async fn find_many<T: Message + Serialize + for<'a> Deserialize<'a> + Clone + Default>(
        &self,
        bucket: B,
        options: FindOptions,
    ) -> Result<Vec<T>, Status> {
        let filter = options.filter.clone();
        self.config_store
            .find_many(bucket.clone(), options)
            .await
            .map_err(|e| {
                log::error!(bucket:?, filter:?, err:? = e; "Failed finding records");
                to_status(e)
            })?
            .into_iter()
            .map(|model| {
                model.try_into().map_err(|e| {
                    log::error!(bucket:?, filter:?, err:? = e; "Failed converting found model into a message");
                    to_status(e.into())
                })
            })
            .collect()
    }

    pub async fn update<T: Message + Serialize + for<'a> Deserialize<'a> + Clone + Default>(
        &self,
        bucket: B,
        model: &T,
    ) -> Result<T, Status> {
        self.config_store
            .update(bucket.clone(), model_from_message(model)?)
            .await
            .map_err(|e| {
                log::error!(bucket:?, err:? = e; "Failed updating record");
                to_status(e)
            })?
            .try_into()
            .map_err(|e| {
                log::error!(bucket:?, err:? = e; "Failed converting updated model back into a message");
                Status::internal(e.to_string())
            })
    }
}

fn to_status(e: Error) -> Status {
    match e {
        Error::AlreadyExists(e) => Status::already_exists(e.to_string()),
        Error::FailedPrecondition(e) => Status::failed_precondition(e.to_string()),
        Error::Internal(e) => Status::internal(e.to_string()),
        Error::InvalidArgument(e) => Status::invalid_argument(e.to_string()),
        Error::MigrationFailed(e) => Status::internal(e.to_string()),
        Error::NotFound(e) => Status::not_found(e.to_string()),
        Error::Unavailable(e) => Status::unavailable(e.to_string()),
        Error::Unimplemented(e) => Status::unimplemented(e.to_string()),
    }
}