ferrox-database-firebase 0.8.0

Firebase Firestore/RealtimeDB repository connector for Ferrox ecosystem.
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

use async_trait::async_trait;
use ferrox_database_core::Repository;
use ferrox_errors::AppError;
use reqwest::Client;
use serde::{Serialize, de::DeserializeOwned};
use std::marker::PhantomData;

/// A Firebase Realtime Database/Firestore backed repository implementation.
pub struct FirebaseRepository<T> {
    client: Client,
    base_url: String,
    collection: String,
    _marker: PhantomData<T>,
}

impl<T> FirebaseRepository<T> {
    pub fn new(client: Client, project_id: &str, collection: &str) -> Self {
        Self {
            client,
            base_url: format!("https://{}.firebaseio.com", project_id),
            collection: collection.to_string(),
            _marker: PhantomData,
        }
    }
}

#[async_trait]
impl<T> Repository<T, String> for FirebaseRepository<T>
where
    T: Serialize + DeserializeOwned + Send + Sync + Clone,
{
    async fn find_by_id(&self, id: String) -> Result<Option<T>, AppError> {
        let url = format!("{}/{}/{}.json", self.base_url, self.collection, id);
        let res = self.client.get(&url).send().await.map_err(|e| AppError::DatabaseError(e.to_string()))?;
        
        if res.status().is_success() {
            let entity: Option<T> = res.json().await.map_err(|e| AppError::DatabaseError(e.to_string()))?;
            Ok(entity)
        } else {
            Ok(None)
        }
    }

    async fn find_all(&self) -> Result<Vec<T>, AppError> {
        let url = format!("{}/{}.json", self.base_url, self.collection);
        let res = self.client.get(&url).send().await.map_err(|e| AppError::DatabaseError(e.to_string()))?;
        
        if res.status().is_success() {
            let map: std::collections::HashMap<String, T> = res.json().await.map_err(|e| AppError::DatabaseError(e.to_string()))?;
            Ok(map.into_values().collect())
        } else {
            Ok(vec![])
        }
    }

    async fn insert(&self, entity: T) -> Result<T, AppError> {
        let url = format!("{}/{}.json", self.base_url, self.collection);
        
        self.client.post(&url)
            .json(&entity)
            .send()
            .await
            .map_err(|e| AppError::DatabaseError(e.to_string()))?;
            
        Ok(entity)
    }

    async fn update(&self, id: String, entity: T) -> Result<T, AppError> {
        let url = format!("{}/{}/{}.json", self.base_url, self.collection, id);
        
        self.client.put(&url)
            .json(&entity)
            .send()
            .await
            .map_err(|e| AppError::DatabaseError(e.to_string()))?;
            
        Ok(entity)
    }

    async fn delete(&self, id: String) -> Result<(), AppError> {
        let url = format!("{}/{}/{}.json", self.base_url, self.collection, id);
        self.client.delete(&url)
            .send()
            .await
            .map_err(|e| AppError::DatabaseError(e.to_string()))?;
            
        Ok(())
    }
}