atac 0.18.0

Arguably a Terminal API Client. Feature-full, free, open-source, offline and account-less.
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

use boa_engine::{Context, Source};
use indexmap::IndexMap;
use tracing::{info, trace};

use crate::app::app::App;
use crate::models::request::Request;
use crate::models::response::RequestResponse;
use crate::models::scripts::ScriptType;

impl App<'_> {
    pub fn modify_request_script(&mut self, collection_index: usize, request_index: usize, script_type: &ScriptType, script: Option<String>) -> anyhow::Result<()> {
        let local_selected_request = self.get_request_as_local_from_indexes(&(collection_index, request_index));

        {
            let mut selected_request = local_selected_request.write();

            match script_type {
                ScriptType::Pre => selected_request.scripts.pre_request_script = script,
                ScriptType::Post => selected_request.scripts.post_request_script = script,
            }

            info!("{}-request script set", script_type);
        }

        self.save_collection_to_file(collection_index);

        Ok(())
    }
}

const JS_CONSOLE: &str = r#"
let console_log_output = "";

globalThis.console = {
  log: (msg) => {
    console_log_output += msg + '\n';
    return msg;
  }
}
"#;

const JS_UTILS: &str = r#"
function pretty_print(data) {
    console.log(JSON.stringify(data, null, 2));
}
"#;

pub fn execute_pre_request_script(user_script: &String, request: &Request, env: Option<IndexMap<String, String>>) -> (Option<Request>, Option<IndexMap<String, String>>, String) {
    // Instantiate the execution context
    let mut context = Context::default();

    let request_json = serde_json::to_string(request).unwrap();
    let env_json = match &env {
        Some(env) => serde_json::to_string(env).unwrap(),
        None => String::from("undefined")
    };

    let script = format!(r#"
        let request = {request_json};
        let env = {env_json};

        {JS_CONSOLE}
        {JS_UTILS}

        /* Start of the user script */

        {user_script}

        /* End of the user script */

        JSON.stringify([request, env, console_log_output])
    "#);

    trace!("Executing pre-request script");

    let result = match context.eval(Source::from_bytes(&script)) {
        Ok(result) => result,
        Err(error) => {
            return (None, env, error.to_string())
        }
    };

    let stringed_result = result.as_string().unwrap().to_std_string_escaped();

    let (result_request, result_env_values, console_output) = match serde_json::from_str::<(Request, Option<IndexMap<String, String>>, String)>(&stringed_result) {
        Ok((result_request, result_env_values, console_output)) => (Some(result_request), result_env_values, console_output),
        Err(error) => (None, env, error.to_string())
    };

    return (result_request, result_env_values, console_output);
}

pub fn execute_post_request_script(user_script: &String, response: &RequestResponse, env: Option<IndexMap<String, String>>) -> (Option<RequestResponse>, Option<IndexMap<String, String>>, String) {
    // Instantiate the execution context
    let mut context = Context::default();

    let response_json = serde_json::to_string(response).unwrap();
    let env_json = match &env {
        Some(env) => serde_json::to_string(env).unwrap(),
        None => String::from("undefined")
    };

    let script = format!(r#"
        let response = {response_json};
        let env = {env_json};

        {JS_CONSOLE}
        {JS_UTILS}

        /* Start of the user script */

        {user_script}

        /* End of the user script */

        JSON.stringify([response, env, console_log_output])
    "#);

    trace!("Executing post-request script");

    let result = match context.eval(Source::from_bytes(&script)) {
        Ok(result) => result,
        Err(error) => {
            return (None, env, error.to_string())
        }
    };

    let stringed_result = result.as_string().unwrap().to_std_string_escaped();

    let (response_result, result_env_values, console_output) = match serde_json::from_str::<(RequestResponse, Option<IndexMap<String, String>>, String)>(&stringed_result) {
        Ok((mut response_result, result_env_values, console_output)) => {
            // Avoid loosing those fields since they are not serialized
            response_result.duration = response.duration.clone();
            response_result.status_code = response.status_code.clone();

            (Some(response_result), result_env_values, console_output)
        },
        Err(error) => (None, env, error.to_string())
    };

    return (response_result, result_env_values, console_output);
}