hop-cli 0.2.61

Interact with Hop in your terminal
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

use std::io::Write;

use anyhow::{bail, Context, Result};
use regex::Regex;
use tabwriter::TabWriter;

use super::types::{CreateProject, Project, Quotas, SingleProjectResponse, Sku, SkuResponse};
use crate::state::http::HttpClient;

pub fn format_projects(projects: &Vec<Project>, title: bool) -> Vec<String> {
    let mut tw = TabWriter::new(vec![]);

    if title {
        writeln!(&mut tw, "NAME\tNAMESPACE\tID\tCREATED\tTYPE").unwrap();
    }

    for project in projects {
        writeln!(
            &mut tw,
            "{}\t/{}\t{}\t{}\t{}",
            project.name.clone(),
            project.namespace,
            project.id,
            project.created_at,
            project.type_,
        )
        .unwrap();
    }

    String::from_utf8(tw.into_inner().unwrap())
        .unwrap()
        .lines()
        .map(std::string::ToString::to_string)
        .collect()
}

pub fn format_project(project: &Project) -> String {
    format_projects(&vec![project.clone()], false)[0].clone()
}

pub async fn create_project(
    http: &HttpClient,
    name: &str,
    namespace: &str,
    payment_method_id: &str,
) -> Result<Project> {
    let data = http
        .request::<SingleProjectResponse>(
            "POST",
            "/projects",
            Some((
                serde_json::to_vec(&CreateProject {
                    name: name.to_string(),
                    namespace: namespace.to_string(),
                    payment_method_id: payment_method_id.to_string(),
                })
                .unwrap()
                .into(),
                "application/json",
            )),
        )
        .await?
        .ok_or_else(|| anyhow::anyhow!("Error while parsing response"))?
        .project;

    Ok(data)
}

pub fn validate_namespace(namespace: &str) -> Result<()> {
    let regex = Regex::new(r"(?i)[a-z0-9_]")?;

    if namespace.len() > 15 {
        bail!("Namespace must be less than 15 characters")
    } else if !regex.is_match(namespace) {
        bail!("Namespace must contain only letters, numbers and underscores")
    }

    Ok(())
}

pub async fn get_quotas(http: &HttpClient, project_id: &str) -> Result<Quotas> {
    http.request::<Quotas>("GET", &format!("/quotas?project={project_id}"), None)
        .await?
        .context("Error while parsing response")
}

pub async fn get_skus(http: &HttpClient) -> Result<Vec<Sku>> {
    Ok(http
        .request::<SkuResponse>("GET", "/skus", None)
        .await?
        .context("Error while parsing response")?
        .skus)
}