unkey 0.2.0

An asynchronous Rust SDK for the Unkey API.
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
138
139
140
141
142
143
144
145
146
147
148
149
150

# Unkey for Rust

An asynchronous Rust SDK for the [Unkey API](https://docs.unkey.dev/introduction).

All the API key management features you love, now with more type safety!

## MSRV

The minimum supported Rust verision for the project is `1.63.0`.

## Documentation

Full documentation can be found at [https://docs.rs/unkey](https://docs.rs/unkey).

## Setup

### Using `cargo`

```bash
$ cargo add unkey
```

### Manually

Add the following to your `Cargo.toml` dependencies array:

```toml
unkey = "0.1" # I won't forget to update this™
```

## Examples

### Verifying a key

```rust
use unkey::models::{VerifyKeyRequest, Wrapped};
use unkey::Client;

async fn verify_key() {
    let c = Client::new("unkey_ABC");
    let req = VerifyKeyRequest::new("test_DEF");

    match c.verify_key(req).await {
        Wrapped::Ok(res) => println!("{res:?}"),
        Wrapped::Err(err) => eprintln!("{err:?}"),
    }
}
```

### Creating a key

```rust
use unkey::models::{CreateKeyRequest, Wrapped};
use unkey::Client;

async fn create_key() {
    let c = Client::new("unkey_ABC");
    let req = CreateKeyRequest::new("api_123")
        .set_prefix("test")
        .set_remaining(100)
        .set_name("test_name")
        .set_owner_id("jonxslays");

    match c.create_key(req).await {
        Wrapped::Ok(res) => println!("{res:?}"),
        Wrapped::Err(err) => eprintln!("{err:?}"),
    }
}
```

### Updating a key

```rust
use unkey::models::{UpdateKeyRequest, Wrapped};
use unkey::Client;

async fn update_key() {
    let c = Client::new("unkey_ABC");
    let req = UpdateKeyRequest::new("key_XYZ")
        .set_name(Some("new_name")) // Update the keys name
        .set_ratelimit(None); // Remove any ratelimit on the key

    match c.update_key(req).await {
        Wrapped::Ok(res) => println!("{res:?}"),
        Wrapped::Err(err) => eprintln!("{err:?}"),
    }
}
```

### Revoking a key

```rust
use unkey::models::{RevokeKeyRequest, Wrapped};
use unkey::Client;

async fn revoke_key() {
    let c = Client::new("unkey_ABC");
    let req = RevokeKeyRequest::new("key_XYZ");

    match c.revoke_key(req).await {
        Wrapped::Ok(res) => println!("{res:?}"),
        Wrapped::Err(err) => eprintln!("{err:?}"),
    }
}
```

### Listing api keys

```rust
use unkey::models::{ListKeysRequest, Wrapped};
use unkey::Client;

async fn list_keys() {
    let c = Client::new("unkey_ABC");
    let req = ListKeysRequest::new("api_123");

    match c.list_keys(req).await {
        Wrapped::Ok(res) => println!("{res:?}"),
        Wrapped::Err(err) => eprintln!("{err:?}"),
    }
}
```

### Getting api information

```rust
use unkey::models::{GetApiRequest, Wrapped};
use unkey::Client;

async fn get_api() {
    let c = Client::new("unkey_ABC");
    let req = GetApiRequest::new("api_123");

    match c.get_api(req).await {
        Wrapped::Ok(res) => println!("{res:?}"),
        Wrapped::Err(err) => eprintln!("{err:?}"),
    }
}
```

## Contributions

Unkey for Rust is open to contributions! Check out the
[contributing guide](https://github.com/Jonxslays/unkey/blob/master/CONTRIBUTING.md)
to get started.

## License

Unkey for Rust is licensed under the
[MIT License](https://github.com/Jonxslays/unkey/blob/master/LICENSE).