hen 0.8.0

Run API collections from the command line.
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

use clap::{self, Parser};
use simple_logger;
use std::path::PathBuf;

use prompt_generator::{collection_prompt, request_prompt, scan_directory};

mod collection;
mod parser;
mod prompt_generator;
mod request;
mod benchmark;

// hen -> prompt for a collection in CWD
// hen <dir> -> prompt for a collections in a specific directory
// hen <file> -> prompt to run a specific request
// hen <file> --all -> run all requests
#[derive(clap::Parser, Debug)]
#[command(name = "hen")]
#[command(version = env!("CARGO_PKG_VERSION"))]
#[command(about = "Command line API client.")]
struct Cli {
    path: Option<String>,
    selector: Option<String>,

    #[arg(long)]
    export: bool,

    #[arg(long)]
    benchmark: Option<usize>,

    #[arg(short = 'v', long)]
    verbose: bool,
}

#[tokio::main]
async fn main() {
    let args: Cli = Cli::parse();

    if args.verbose {
        simple_logger::init_with_level(log::Level::Debug).expect("Failed to initialize logger.");
    }

    log::debug!("Starting hen with args {:?}", args);

    let cwd = std::env::current_dir().unwrap();

    // get the collection to load, either
    // 1. directly from, if supplied a filepath
    // 2. or via a prompt if supplied a directory
    let collection = match args.path {
        Some(path) => {
            // is the path a directory or a file?
            let path = PathBuf::from(path);
            if path.is_dir() {
                // if there is only one valid file, load it automatically and skip the prompt
                let hen_files = scan_directory(path.clone());
                if hen_files.len() == 1 {
                    collection::Collection::new(hen_files.get(0).unwrap().clone())
                } else {
                    // prompt for a collection in the directory
                    collection_prompt(path)
                }
            } else {
                // prompt for a request in the file
                collection::Collection::new(path)
            }
        }

        None => match collection_prompt(cwd) {
            collection => collection,
        },
    };

    let collection = match collection {
        Ok(collection) => collection,
        Err(e) => {
            eprintln!("Error: {}", e);
            return;
        }
    };

    log::debug!("PARSED COLLECTION\n{:#?}", collection);

    // get the requests to execute
    // this is a vector to allow for the possibility of running all requests.
    // if a selector is provided, it is used to select a request instead of prompting the user.
    // Else, the user is prompted to select a request if there is more than one in a collection.
    // if there is only one request, it is automatically selected and the prompt is skipped.
    let requests = match args.selector {
        Some(selector) => {
            match selector {
                // return all requests
                ref s if s == "all" => collection.requests,
                // return a specific request
                _ => {
                    // parse the selector as an integer
                    let index = selector.parse::<usize>().unwrap();

                    // return the request at the index
                    let index_request = collection.requests.get(index);

                    match index_request {
                        Some(request) => vec![request.clone()],
                        None => {
                            eprintln!("Request not found: {}", selector);
                            return;
                        }
                    }
                }
            }
        }
        None => {
            if collection.requests.len() == 1 {
                vec![collection.requests[0].clone()]
            } else {
                vec![request_prompt(collection)]
            }
        }
    };

    // exec array of requests
    for req in requests {

        if args.export {
            println!("{}", req.as_curl());
            continue;
        }

        if let Some(count) = args.benchmark {
            benchmark::benchmark(req.clone(), count).await;
            continue;
        }

        let response = req.exec().await.unwrap();
        println!("{}", response);
    }
}