chamber_core/
core.rs

1use crate::errors::DatabaseError;
2use crate::secrets::{EncryptedSecret, Secret, SecretInfo};
3use chrono::{DateTime, Utc};
4use std::sync::Arc;
5use tokio::sync::Mutex;
6
7use serde::{Deserialize, Serialize};
8
9use crate::users::User;
10
11#[derive(Debug, Serialize, Deserialize)]
12pub struct AuthBody {
13    pub access_token: String,
14    pub token_type: String,
15}
16
17impl AuthBody {
18    pub fn new(access_token: String) -> Self {
19        Self {
20            access_token,
21            token_type: "Bearer".to_string(),
22        }
23    }
24}
25
26#[derive(Deserialize)]
27pub struct CreateSecretParams {
28    pub key: String,
29    pub value: String,
30    pub tags: Option<Vec<String>>,
31    pub access_level: Option<i32>,
32    pub role_whitelist: Option<Vec<String>>,
33}
34
35#[async_trait::async_trait]
36pub trait Database {
37    async fn view_all_secrets_admin(
38        &self,
39    ) -> Result<Vec<EncryptedSecret>, DatabaseError>;
40    async fn view_all_secrets(
41        &self,
42        user: User,
43        tag: Option<String>,
44    ) -> Result<Vec<SecretInfo>, DatabaseError>;
45    async fn view_secret_decrypted(&self, user: User, key: String)
46        -> Result<Secret, DatabaseError>;
47    async fn view_secret(&self, user: User, key: String) -> Result<EncryptedSecret, DatabaseError>;
48    async fn create_secret(&self, secret: EncryptedSecret) -> Result<(), DatabaseError>;
49    async fn update_secret(
50        &self,
51        key: String,
52        secret: EncryptedSecret,
53    ) -> Result<(), DatabaseError>;
54    async fn rekey_all_secrets(&self, secrets: Vec<EncryptedSecret>) -> Result<(), DatabaseError>;
55    async fn delete_secret(&self, key: String) -> Result<(), DatabaseError>;
56    async fn view_users(&self) -> Result<Vec<User>, DatabaseError>;
57    async fn get_user_from_name(&self, id: String) -> Result<User, DatabaseError>;
58    async fn get_user_from_password(&self, password: String) -> Result<User, DatabaseError>;
59    async fn create_user(&self, user: User) -> Result<String, DatabaseError>;
60    async fn update_user(&self, user: User) -> Result<(), DatabaseError>;
61    async fn delete_user(&self, name: String) -> Result<(), DatabaseError>;
62}
63
64#[derive(Clone)]
65pub struct LockedStatus {
66    pub is_sealed: Arc<Mutex<bool>>,
67    pub relock_datetime: Option<DateTime<Utc>>,
68}
69
70impl Default for LockedStatus {
71    fn default() -> Self {
72        Self::new()
73    }
74}
75
76impl LockedStatus {
77    fn new() -> Self {
78        Self {
79            is_sealed: Arc::new(Mutex::new(true)),
80            relock_datetime: None,
81        }
82    }
83    pub async fn unlock(&self) -> Result<bool, DatabaseError> {
84        let mut state = self.is_sealed.lock().await;
85
86        *state = false;
87
88        Ok(true)
89    }
90
91    pub async fn is_locked(&self) -> bool {
92        let state = self.is_sealed.lock().await;
93
94        *state
95    }
96}