homeboy 0.50.1

CLI for multi-component deployment and development workflow automation
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

use serde::{Deserialize, Serialize};
use serde_json::Value;

use crate::error::{Error, Result};
use crate::http::ApiClient;
use crate::project;

#[derive(Debug, Clone, Serialize)]

pub struct ApiOutput {
    pub project_id: String,
    pub method: String,
    pub endpoint: String,
    pub response: Value,
}

/// Single entry point for API requests.
///
/// Input is always JSON:
/// ```json
/// {"projectId": "my-project", "method": "GET", "endpoint": "/wp/v2/posts", "body": null}
/// ```
pub fn run(input: &str) -> Result<(ApiOutput, i32)> {
    let parsed: ApiInput = serde_json::from_str(input).map_err(|e| {
        Error::validation_invalid_json(
            e,
            Some("parse api input".to_string()),
            Some(input.chars().take(200).collect::<String>()),
        )
    })?;

    let proj = project::load(&parsed.project_id)?;
    let client = ApiClient::new(&parsed.project_id, &proj.api)?;

    let body = parsed
        .body
        .unwrap_or_else(|| Value::Object(serde_json::Map::new()));

    let response = match parsed.method.to_uppercase().as_str() {
        "GET" => client.get(&parsed.endpoint)?,
        "POST" => client.post(&parsed.endpoint, &body)?,
        "PUT" => client.put(&parsed.endpoint, &body)?,
        "PATCH" => client.patch(&parsed.endpoint, &body)?,
        "DELETE" => client.delete(&parsed.endpoint)?,
        _ => {
            return Err(Error::validation_invalid_argument(
                "method",
                format!("Invalid HTTP method: {}", parsed.method),
                None,
                Some(vec![
                    "GET".into(),
                    "POST".into(),
                    "PUT".into(),
                    "PATCH".into(),
                    "DELETE".into(),
                ]),
            ));
        }
    };

    Ok((
        ApiOutput {
            project_id: parsed.project_id,
            method: parsed.method.to_uppercase(),
            endpoint: parsed.endpoint,
            response,
        },
        0,
    ))
}

#[derive(Debug, Deserialize)]

struct ApiInput {
    project_id: String,
    method: String,
    endpoint: String,
    body: Option<Value>,
}