wami 0.17.1

Who Am I - Multicloud Identity, IAM, STS, and SSO operations library for Rust
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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

//! Role Store Implementation for InMemoryWamiStore

use crate::store::memory::InMemoryWamiStore;
use crate::store::traits::RoleStore;
use crate::wami::identity::Role;
use async_trait::async_trait;
use wami_core::error::Result;
use wami_core::types::PaginationParams;

#[async_trait]
impl RoleStore for InMemoryWamiStore {
    async fn create_role(&mut self, role: Role) -> Result<Role> {
        self.roles.insert(role.role_name.clone(), role.clone());
        Ok(role)
    }

    async fn get_role(&self, role_name: &str) -> Result<Option<Role>> {
        Ok(self.roles.get(role_name).cloned())
    }

    async fn update_role(&mut self, role: Role) -> Result<Role> {
        self.roles.insert(role.role_name.clone(), role.clone());
        Ok(role)
    }

    async fn delete_role(&mut self, role_name: &str) -> Result<()> {
        self.roles.remove(role_name);
        Ok(())
    }

    async fn list_roles(
        &self,
        path_prefix: Option<&str>,
        pagination: Option<&PaginationParams>,
    ) -> Result<(Vec<Role>, bool, Option<String>)> {
        let mut roles: Vec<Role> = self.roles.values().cloned().collect();

        // Apply path prefix filter
        if let Some(prefix) = path_prefix {
            // Empty string prefix should only match empty paths, not all paths
            if prefix.is_empty() {
                roles.retain(|role| role.path.is_empty());
            } else {
                roles.retain(|role| role.path.starts_with(prefix));
            }
        }

        roles.sort_by(|a, b| a.role_name.cmp(&b.role_name));

        let mut is_truncated = false;
        let mut marker = None;

        if let Some(pagination) = pagination {
            if let Some(max_items) = pagination.max_items {
                if max_items > 0 && roles.len() > max_items as usize {
                    roles.truncate(max_items as usize);
                    is_truncated = true;
                    if let Some(last_role) = roles.last() {
                        marker = Some(last_role.role_name.clone());
                    }
                } else if max_items == 0 {
                    // max_items = 0 means return empty list but indicate truncation if there are items
                    is_truncated = !roles.is_empty();
                    roles.clear();
                }
            }
        }

        Ok((roles, is_truncated, marker))
    }

    // Managed policy attachment methods
    async fn attach_role_policy(&mut self, role_name: &str, policy_arn: &str) -> Result<()> {
        let policies = self
            .role_attached_policies
            .entry(role_name.to_string())
            .or_default();

        if !policies.contains(&policy_arn.to_string()) {
            policies.push(policy_arn.to_string());
        }
        Ok(())
    }

    async fn detach_role_policy(&mut self, role_name: &str, policy_arn: &str) -> Result<()> {
        if let Some(policies) = self.role_attached_policies.get_mut(role_name) {
            policies.retain(|p| p != policy_arn);
        }
        Ok(())
    }

    async fn list_attached_role_policies(&self, role_name: &str) -> Result<Vec<String>> {
        Ok(self
            .role_attached_policies
            .get(role_name)
            .cloned()
            .unwrap_or_default())
    }

    // Inline policy methods
    async fn put_role_policy(
        &mut self,
        role_name: &str,
        policy_name: &str,
        policy_document: String,
    ) -> Result<()> {
        let policies = self
            .role_inline_policies
            .entry(role_name.to_string())
            .or_default();

        policies.insert(policy_name.to_string(), policy_document);
        Ok(())
    }

    async fn get_role_policy(&self, role_name: &str, policy_name: &str) -> Result<Option<String>> {
        Ok(self
            .role_inline_policies
            .get(role_name)
            .and_then(|policies| policies.get(policy_name).cloned()))
    }

    async fn delete_role_policy(&mut self, role_name: &str, policy_name: &str) -> Result<()> {
        if let Some(policies) = self.role_inline_policies.get_mut(role_name) {
            policies.remove(policy_name);
        }
        Ok(())
    }

    async fn list_role_policies(&self, role_name: &str) -> Result<Vec<String>> {
        Ok(self
            .role_inline_policies
            .get(role_name)
            .map(|policies| policies.keys().cloned().collect())
            .unwrap_or_default())
    }
}