goiam 0.3.0

Rust SDK for Go IAM - A lightweight Identity and Access Management server
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

# Go IAM SDK - Rust

[![Crates.io](https://img.shields.io/crates/v/goiam)](https://crates.io/crates/goiam)
[![Documentation](https://docs.rs/goiam/badge.svg)](https://docs.rs/goiam)
[![License](https://img.shields.io/crates/l/goiam)](https://github.com/melvinodsa/go-iam-sdk/blob/main/LICENSE)

Rust SDK for Go IAM API - Async/Await Support

## Installation

Add this to your `Cargo.toml`:

```toml
[dependencies]
goiam-rust = "0.1.0"
tokio = { version = "1.0", features = ["full"] }
```

## Usage

```rust
use goiam_rust::{new_service, Service, Resource};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize the service
    let service = new_service(
        "https://api.goiam.com".to_string(),
        "your-client-id".to_string(),
        "your-secret".to_string()
    );

    // Verify a code and get access token
    match service.verify("authorization-code").await {
        Ok(token) => {
            println!("Access Token: {}", token);

            // Get user information
            let user = service.me(&token).await?;
            println!("User: {} ({})", user.name, user.email);

            // Create a resource
            let resource = Resource::new("resource-1".to_string(), "My Resource".to_string());
            service.create_resource(&resource, &token).await?;
            println!("Resource created successfully");
        },
        Err(e) => eprintln!("Verification failed: {}", e),
    }

    Ok(())
}
```

## API Reference

### Service Trait

The main interface for interacting with Go IAM API:

```rust
#[async_trait]
pub trait Service: Send + Sync {
    async fn verify(&self, code: &str) -> Result<String, GoIamError>;
    async fn me(&self, token: &str) -> Result<User, GoIamError>;
    async fn create_resource(&self, resource: &Resource, token: &str) -> Result<(), GoIamError>;
}
```

### Types

```rust
pub struct User {
    pub id: String,
    pub project_id: String,
    pub name: String,
    pub email: String,
    pub phone: String,
    pub enabled: bool,
    pub profile_pic: String,
    pub expiry: Option<String>,
    pub roles: HashMap<String, serde_json::Value>,
    pub resources: HashMap<String, serde_json::Value>,
    pub policies: HashMap<String, serde_json::Value>,
    pub created_at: Option<String>,
    pub created_by: String,
    pub updated_at: Option<String>,
    pub updated_by: String,
}

pub struct Resource {
    pub id: String,
    pub name: String,
}
```

### Error Handling

```rust
use goiam_rust::{GoIamError, Service};

match service.verify("code").await {
    Ok(token) => println!("Success: {}", token),
    Err(GoIamError::Http(status)) => eprintln!("HTTP error: {}", status),
    Err(GoIamError::Request(e)) => eprintln!("Request error: {}", e),
    Err(GoIamError::Parse(e)) => eprintln!("Parse error: {}", e),
    Err(GoIamError::Api(msg)) => eprintln!("API error: {}", msg),
}
```

## Testing

Run the tests with:

```bash
cargo test
```

Run tests with output:

```bash
cargo test -- --nocapture
```

## License

This project is licensed under the MIT License.