dotenv-vault 0.1.2

An extension to dotenvy supporting .env.vault files
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

use argh::FromArgs;
use std::env;
use std::path::PathBuf;
use std::process::{exit, Command, Stdio};

#[derive(FromArgs, PartialEq, Debug)]
/// The CLI program to load the .env.vault file and run the specified program with the specified arguments.
///
/// You have to set the DOTENV_KEY environment variable before calling dotenv-vault.
///
/// Example:
/// dotenv-vault run -- my_program arg1 arg2
struct Opts {
    #[argh(subcommand)]
    commands: Commands,
}

#[derive(FromArgs, PartialEq, Debug)]
#[argh(subcommand)]
enum Commands {
    Run(Run),
}

#[derive(FromArgs, PartialEq, Debug)]
/// Load the .env.vault file and run the specified program with the specified arguments.
#[argh(subcommand, name = "run")]
struct Run {
    #[argh(switch, long = "override")]
    /// whether to override the existing environment variables
    override_: bool,

    #[argh(option)]
    /// current working directory to run the program in
    cwd: Option<PathBuf>,

    #[argh(positional)]
    /// the program to run
    program: String,

    #[argh(positional)]
    /// the arguments to pass to the program
    program_args: Vec<String>,
}

#[derive(Debug)]
#[repr(i32)]
enum CLIError {
    EnvLoad = 1,
    EnvOverrideLoad = 2,
    ProgramExecution = 3,
    CwdChange = 4,
}

fn main() {
    let opts = argh::from_env::<Opts>();

    match opts.commands {
        Commands::Run(run_opts) => {
            let current_cwd = env::current_dir().unwrap();

            if let Some(given_cwd) = run_opts.cwd {
                env::set_current_dir(given_cwd).unwrap_or_else(|err| {
                    eprintln!("Failed to change the current working directory: {}", err);
                    exit(CLIError::CwdChange as i32);
                });
            }

            // Load the .env.vault file
            if run_opts.override_ {
                dotenv_vault::dotenv_override().unwrap_or_else(|err| {
                    eprintln!("Failed to load env: {}", err);
                    exit(CLIError::EnvOverrideLoad as i32);
                });
            } else {
                dotenv_vault::dotenv().unwrap_or_else(|err| {
                    eprintln!("Failed to load env: {}", err);
                    exit(CLIError::EnvLoad as i32);
                });
            };

            // Run the specified program with the specified arguments
            let output = Command::new(&run_opts.program)
                .args(run_opts.program_args)
                .envs(env::vars())
                .stdin(Stdio::inherit())
                .stdout(Stdio::inherit())
                .stderr(Stdio::inherit())
                .output()
                .unwrap_or_else(|err| {
                    eprintln!("Failed to execute program {}: {}", run_opts.program, err);
                    exit(CLIError::ProgramExecution as i32);
                });

            // Restore the current working directory
            env::set_current_dir(current_cwd).unwrap_or_else(|err| {
                eprintln!("Failed to change the current working directory: {}", err);
                exit(CLIError::CwdChange as i32);
            });

            if !output.status.success() {
                exit(
                    output
                        .status
                        .code()
                        .unwrap_or(CLIError::ProgramExecution as i32),
                );
            }
        }
    }
}