vaultarq 0.1.9

Rust SDK for Vaultarq - The developer-first, invisible secrets manager
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

# vaultarq

> Rust SDK for Vaultarq - The developer-first, invisible secrets manager

This SDK provides a seamless integration with Vaultarq for Rust applications, automatically loading secrets from your Vaultarq vault into your application's environment variables.

## Installation

Add this to your `Cargo.toml`:

```toml
[dependencies]
vaultarq = "0.1.0"
```

## Requirements

- Vaultarq CLI installed and initialized
- Rust 1.56 or higher (for edition 2021)

## Usage

### Basic Usage

```rust
use vaultarq::init;

fn main() {
    // Load secrets into environment variables
    init().unwrap();
    
    // Now use secrets from environment
    println!("API_KEY: {}", std::env::var("API_KEY").unwrap_or_default());
}
```

### With Options

```rust
use vaultarq::{Config, init_with_config};

fn main() {
    // Configure options
    let config = Config::new()
        .with_environment("prod")
        .with_bin_path("/usr/local/bin/vaultarq")
        .with_throw_if_not_found(true);
    
    // Load secrets with custom config
    init_with_config(&config).unwrap();
}
```

### Checking Availability

```rust
use vaultarq::{init, is_available};

fn main() {
    // Check if Vaultarq is available
    if is_available() {
        init().unwrap();
    } else {
        println!("Vaultarq not found, using fallback");
        // ... your fallback logic
    }
}
```

### With Actix Web

```rust
use actix_web::{web, App, HttpResponse, HttpServer, Responder};
use vaultarq::init;

async fn index() -> impl Responder {
    let db_name = std::env::var("DB_NAME").unwrap_or_else(|_| "unknown".to_string());
    HttpResponse::Ok().body(format!("Connected to database: {}", db_name))
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    // Load secrets before starting the server
    init().unwrap_or_else(|e| {
        eprintln!("Failed to load secrets: {}", e);
        // Continue anyway
    });
    
    HttpServer::new(|| {
        App::new()
            .route("/", web::get().to(index))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}
```

## API

### `init() -> Result<(), Error>`

Loads secrets from the Vaultarq vault into environment variables using default configuration.

### `init_with_config(config: &Config) -> Result<(), Error>`

Loads secrets from the Vaultarq vault into environment variables using custom configuration.

### `is_available() -> bool`

Checks if Vaultarq is installed and accessible.

### `Config`

Configuration struct for customizing how secrets are loaded.

#### Methods

- `new() -> Config`: Creates a new configuration with default values
- `with_bin_path(path: &str) -> Self`: Sets the path to the Vaultarq executable
- `with_throw_if_not_found(throw: bool) -> Self`: Sets whether to throw an error if Vaultarq is not found
- `with_environment(env: &str) -> Self`: Sets the environment to load secrets from
- `with_format(format: Format) -> Self`: Sets the format to export secrets in

### `Format`

Enum for specifying the export format:
- `Format::Bash` (default): Export as `export KEY="VALUE"` statements
- `Format::Dotenv`: Export as `KEY=VALUE` statements
- `Format::Json`: Export as JSON object

## License

MIT