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

use crate::errors::*;
use crate::vault_store::SecretVaultStore;
use crate::*;
use async_trait::async_trait;
use std::sync::Arc;

#[async_trait]
pub trait SecretVaultView {
    async fn get_secret(&self, secret_name: &SecretName) -> SecretVaultResult<Option<Secret>> {
        self.get_secret_with_version(secret_name, None).await
    }

    async fn require_secret(&self, secret_name: &SecretName) -> SecretVaultResult<Secret> {
        self.require_secret_with_version(secret_name, None).await
    }

    async fn get_secret_with_version(
        &self,
        secret_name: &SecretName,
        secret_version: Option<&SecretVersion>,
    ) -> SecretVaultResult<Option<Secret>> {
        self.get_secret_by_ref(
            &SecretVaultRef::new(secret_name.clone()).opt_secret_version(secret_version.cloned()),
        )
        .await
    }

    async fn require_secret_with_version(
        &self,
        secret_name: &SecretName,
        secret_version: Option<&SecretVersion>,
    ) -> SecretVaultResult<Secret> {
        self.require_secret_by_ref(
            &SecretVaultRef::new(secret_name.clone()).opt_secret_version(secret_version.cloned()),
        )
        .await
    }

    async fn require_secret_by_ref(
        &self,
        secret_ref: &SecretVaultRef,
    ) -> SecretVaultResult<Secret> {
        match self.get_secret_by_ref(secret_ref).await? {
            Some(secret) => Ok(secret),
            None => Err(SecretVaultError::DataNotFoundError(
                SecretVaultDataNotFoundError::new(
                    SecretVaultErrorPublicGenericDetails::new("SECRET_NOT_FOUND".into()),
                    format!("Secret {secret_ref:?} doesn't exist in vault but was required"),
                ),
            )),
        }
    }

    async fn get_secret_by_ref(
        &self,
        secret_ref: &SecretVaultRef,
    ) -> SecretVaultResult<Option<Secret>>;
}

#[derive(Clone)]
pub struct SecretVaultViewer<E>
where
    E: SecretVaultEncryption,
{
    store: Arc<SecretVaultStore<E>>,
}

impl<E> SecretVaultViewer<E>
where
    E: SecretVaultEncryption,
{
    pub fn new(store: Arc<SecretVaultStore<E>>) -> Self {
        Self { store }
    }
}

#[async_trait]
impl<E> SecretVaultView for SecretVaultViewer<E>
where
    E: SecretVaultEncryption + Send + Sync,
{
    async fn get_secret_by_ref(
        &self,
        secret_ref: &SecretVaultRef,
    ) -> SecretVaultResult<Option<Secret>> {
        self.store.get_secret(&secret_ref.key).await
    }
}