wami 0.10.0

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

//! Provider Information for Multi-Cloud Support
//!
//! Tracks native cloud provider details for WAMI resources.

use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};

/// Information about a cloud provider where a resource exists
///
/// # Purpose
///
/// While WAMI uses opaque ARNs externally (`arn:wami:iam:tenant-xxx:user/alice`),
/// we need to track the real native cloud identifiers for interoperability.
///
/// # Example
///
/// ```rust
/// use wami::provider::provider_info::ProviderInfo;
/// use chrono::Utc;
///
/// let aws_info = ProviderInfo {
///     provider_type: "aws".to_string(),
///     native_arn: "arn:aws:iam::123456789012:user/alice".to_string(),
///     resource_id: Some("AIDACKCEVSQ6C2EXAMPLE".to_string()),
///     account_id: "123456789012".to_string(),
///     synced_at: Utc::now(),
/// };
/// ```
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct ProviderInfo {
    /// Provider type ("aws", "gcp", "azure", "custom")
    pub provider_type: String,

    /// Native ARN/URN/Resource ID from the cloud provider
    ///
    /// Examples:
    /// - AWS: `arn:aws:iam::123456789012:user/alice`
    /// - GCP: `projects/my-project/serviceAccounts/alice@...`
    /// - Azure: `/subscriptions/.../providers/Microsoft.Authorization/users/alice`
    pub native_arn: String,

    /// Provider-specific resource ID (optional)
    ///
    /// Examples:
    /// - AWS: `AIDACKCEVSQ6C2EXAMPLE`
    /// - GCP: `123456789012345678`
    /// - Azure: `550e8400-e29b-41d4-a716-446655440000`
    pub resource_id: Option<String>,

    /// Real account/project/subscription ID (non-obfuscated)
    pub account_id: String,

    /// When this provider entry was created/synced
    pub synced_at: DateTime<Utc>,
}

impl ProviderInfo {
    /// Creates a new ProviderInfo with current timestamp
    pub fn new(
        provider_type: impl Into<String>,
        native_arn: impl Into<String>,
        resource_id: Option<String>,
        account_id: impl Into<String>,
    ) -> Self {
        Self {
            provider_type: provider_type.into(),
            native_arn: native_arn.into(),
            resource_id,
            account_id: account_id.into(),
            synced_at: Utc::now(),
        }
    }

    /// Checks if this provider is AWS
    pub fn is_aws(&self) -> bool {
        self.provider_type == "aws"
    }

    /// Checks if this provider is GCP
    pub fn is_gcp(&self) -> bool {
        self.provider_type == "gcp"
    }

    /// Checks if this provider is Azure
    pub fn is_azure(&self) -> bool {
        self.provider_type == "azure"
    }

    /// Checks if this is a custom provider
    pub fn is_custom(&self) -> bool {
        !self.is_aws() && !self.is_gcp() && !self.is_azure()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_provider_info_creation() {
        let info = ProviderInfo::new(
            "aws",
            "arn:aws:iam::123456789012:user/alice",
            Some("AIDACKCEVSQ6C2EXAMPLE".to_string()),
            "123456789012",
        );

        assert_eq!(info.provider_type, "aws");
        assert!(info.is_aws());
        assert!(!info.is_gcp());
    }

    #[test]
    fn test_provider_type_checks() {
        let aws = ProviderInfo::new("aws", "arn:...", None, "123");
        let gcp = ProviderInfo::new("gcp", "projects/...", None, "project-id");
        let azure = ProviderInfo::new("azure", "/subscriptions/...", None, "sub-id");
        let custom = ProviderInfo::new("mycloud", "mycloud://...", None, "tenant-123");

        assert!(aws.is_aws());
        assert!(gcp.is_gcp());
        assert!(azure.is_azure());
        assert!(custom.is_custom());
    }
}