eitri-cli 1.8.0 → 1.9.0-beta.2

package/eitri-cli-v2/src/commands/publish.rs

@@ -0,0 +1,67 @@
+use std::process::exit;
+
+use neon::{
+    context::{Context, FunctionContext},
+    result::JsResult,
+    types::JsPromise,
+};
+
+use crate::{
+    infra::async_runtime::runtime,
+    services::{eitri_manager, workspace},
+};
+
+const DIVISOR: &str = "========================================================";
+
+pub fn execute(
+    mut cx: FunctionContext,
+    environment: String,
+    message: String,
+) -> JsResult<JsPromise> {
+    let init_message = format!("Iniciando publicação de Eitri-App",);
+    println!("{DIVISOR}");
+    println!("\t{init_message}");
+    println!("{DIVISOR}");
+
+    let rt = match runtime(&mut cx) {
+        Ok(rt) => rt,
+        Err(_err) => {
+            eprintln!("Houve um erro ao criar runtime");
+            exit(1);
+        }
+    };
+
+    let channel = cx.channel();
+
+    let (deferred, promise) = cx.promise();
+
+    rt.spawn(async move {
+        let eitri_conf = workspace::read_eitri_conf().await;
+        let version = eitri_conf.version;
+        println!("Versão a ser publicada: {}", version);
+        println!("Environment: {}", environment);
+        println!("Mensagem: {}", message);
+
+        let revision = match eitri_manager::get_revision(&eitri_conf.id, &version).await {
+            Ok(revision) => revision,
+            Err(_err) => {
+                eprintln!("Houve um erro ao buscar revisão.");
+                exit(1)
+            }
+        };
+        match eitri_manager::publish_revision(&revision.id, &environment, &message).await {
+            Ok(_) => {
+                println!("Eitri-App publicado com sucesso!")
+            }
+            Err(err) => {
+                eprintln!("Houve um erro. Error: {:?}", err);
+                exit(1)
+            }
+        }
+        deferred.settle_with(&channel, move |mut cx| {
+            Ok(cx.string("Eitri-App publicado com sucesso!"))
+        });
+    });
+
+    Ok(promise)
+}

package/eitri-cli-v2/src/config/mod.rs

@@ -0,0 +1 @@
+pub mod user_credentials;

package/eitri-cli-v2/src/config/user_credentials.rs

@@ -0,0 +1,38 @@
+use std::{fs, process::exit};
+
+use homedir::get_my_home;
+
+use crate::model::credentials::Credentials;
+
+pub fn get_credentials() -> Result<Credentials, serde_json::Error> {
+    let home_dir = match get_my_home() {
+        Ok(dir) => dir,
+        Err(_) => {
+            eprintln!("Houve um erro ao ler a home do usuário");
+            exit(1)
+        }
+    };
+
+    let home_dir = match home_dir {
+        Some(dir) => dir,
+        _ => exit(1),
+    };
+
+    let credentials_file_path = home_dir.join(".eitri").join("prod-eitri.conf.js");
+
+    let content = match fs::read_to_string(credentials_file_path.to_owned()) {
+        Ok(c) => c,
+        Err(_) => {
+            eprintln!(
+                "Houve um erro ao ler credenciais do usuário, certifique-se de ter feito login"
+            );
+            exit(1)
+        }
+    };
+
+    let content = content.replace("module.exports = ", "");
+
+    let credentials: Credentials = serde_json::from_str(&content)?;
+
+    Ok(credentials)
+}

package/eitri-cli-v2/src/infra/async_runtime.rs

@@ -0,0 +1,9 @@
+use neon::{context::Context, result::NeonResult};
+use once_cell::sync::OnceCell;
+use tokio::runtime::Runtime;
+
+pub fn runtime<'a, C: Context<'a>>(cx: &mut C) -> NeonResult<&'static Runtime> {
+    static RUNTIME: OnceCell<Runtime> = OnceCell::new();
+
+    RUNTIME.get_or_try_init(|| Runtime::new().or_else(|err| cx.throw_error(err.to_string())))
+}

package/eitri-cli-v2/src/infra/http_client.rs

@@ -0,0 +1,484 @@
+// use std::sync::Arc;
+
+use reqwest::{header::HeaderMap, multipart::Form, Client};
+use serde::de::DeserializeOwned;
+use serde::Serialize;
+use serde_derive::Deserialize;
+
+// use crate::services::vegvisir::get_workspace;
+
+// use super::cookie::{get_cookie, write_cookie};
+
+#[allow(dead_code)]
+#[derive(Debug, Deserialize)]
+pub struct ApiError {
+    pub message: String,
+}
+
+#[allow(dead_code)]
+#[derive(Debug)]
+pub enum HttpError {
+    HttpError(reqwest::StatusCode, ApiError),
+    Deserialize(reqwest::Error),
+}
+
+#[allow(dead_code)]
+pub async fn post<T, U>(url: &str, data: U, headers: HeaderMap) -> Result<T, HttpError>
+where
+    T: DeserializeOwned,
+    U: Serialize,
+{
+    let client = get_client(url);
+
+    let response = client
+        .post(url)
+        .headers(headers)
+        .json(&data)
+        .send()
+        .await
+        .map_err(HttpError::Deserialize)?;
+
+    if response.status().is_success() {
+        // write_cookie(&response.headers(), &url);
+        return response.json().await.map_err(HttpError::Deserialize);
+    }
+    let status = response.status();
+    let mensagem = response
+        .text()
+        .await
+        .unwrap_or_else(|_| String::from("Erro desconhecido"));
+    let api_error: ApiError = serde_json::from_str(&mensagem).unwrap_or_else(|_| ApiError {
+        message: String::from("Erro ao relizar parse do JSON"),
+    });
+    Err(HttpError::HttpError(status, api_error))
+}
+
+#[allow(dead_code)]
+pub async fn post_form_data<T>(url: &str, data: Form, headers: HeaderMap) -> Result<T, HttpError>
+where
+    T: DeserializeOwned,
+{
+    let client = get_client(url);
+
+    let response = client
+        .post(url)
+        .headers(headers)
+        .multipart(data)
+        .send()
+        .await
+        .map_err(HttpError::Deserialize)?;
+
+    if response.status().is_success() {
+        // write_cookie(&response.headers(), &url);
+        return response.json().await.map_err(HttpError::Deserialize);
+    }
+    let status = response.status();
+    let mensagem = response
+        .text()
+        .await
+        .unwrap_or_else(|_| String::from("Erro desconhecido"));
+    let api_error: ApiError = serde_json::from_str(&mensagem).unwrap_or_else(|_| ApiError {
+        message: String::from("Erro ao relizar parse do JSON"),
+    });
+    Err(HttpError::HttpError(status, api_error))
+}
+
+#[allow(dead_code)]
+pub async fn get<T>(url: &str, headers: HeaderMap) -> Result<T, HttpError>
+where
+    T: DeserializeOwned,
+{
+    let client = get_client(url);
+
+    let response = client
+        .get(url)
+        .headers(headers)
+        .send()
+        .await
+        .map_err(HttpError::Deserialize)?;
+
+    if response.status().is_success() {
+        // write_cookie(&response.headers(), &url);
+        return response.json().await.map_err(HttpError::Deserialize);
+    }
+    let status = response.status();
+    let mensagem = response
+        .text()
+        .await
+        .unwrap_or_else(|_| String::from("Erro desconhecido"));
+    let api_error: ApiError = serde_json::from_str(&mensagem).unwrap_or_else(|_| ApiError {
+        message: String::from("Erro ao relizar parse do JSON"),
+    });
+    Err(HttpError::HttpError(status, api_error))
+}
+
+#[allow(dead_code)]
+pub async fn put<U>(url: &str, data: U, headers: HeaderMap) -> Result<String, HttpError>
+where
+    U: Serialize,
+{
+    let client = get_client(url);
+
+    let response = client
+        .put(url)
+        .headers(headers)
+        .json(&data)
+        .send()
+        .await
+        .map_err(HttpError::Deserialize)?;
+
+    if response.status().is_success() {
+        // write_cookie(&response.headers(), &url);
+        return response.text().await.map_err(HttpError::Deserialize);
+    }
+
+    let status = response.status();
+    let mensagem = response
+        .text()
+        .await
+        .unwrap_or_else(|_| String::from("Erro desconhecido"));
+    let api_error: ApiError = serde_json::from_str(&mensagem).unwrap_or_else(|_| ApiError {
+        message: String::from("Erro ao relizar parse do JSON"),
+    });
+    Err(HttpError::HttpError(status, api_error))
+}
+
+#[allow(dead_code)]
+pub async fn delete(url: &str, headers: HeaderMap) -> Result<(), HttpError> {
+    let client = get_client(url);
+
+    let response = client
+        .delete(url)
+        .headers(headers)
+        .send()
+        .await
+        .map_err(HttpError::Deserialize)?;
+
+    if response.status().is_success() {
+        // write_cookie(&response.headers(), &url);
+        return Ok(());
+    }
+
+    let status = response.status();
+    let mensagem = response
+        .text()
+        .await
+        .unwrap_or_else(|_| String::from("Erro desconhecido"));
+    let api_error: ApiError = serde_json::from_str(&mensagem).unwrap_or_else(|_| ApiError {
+        message: String::from("Erro ao relizar parse do JSON"),
+    });
+    Err(HttpError::HttpError(status, api_error))
+}
+
+#[allow(dead_code)]
+pub async fn get_default_headers(token: String) -> HeaderMap {
+    let mut headers = HeaderMap::new();
+
+    // let workspace = get_workspace().await;
+
+    headers.append("Authorization", token.parse().unwrap());
+    // headers.append("Workspace-Id", workspace.id.parse().unwrap());
+
+    headers
+}
+
+#[allow(dead_code, unused_variables)]
+fn get_client(request_url: &str) -> Client {
+    // let jar = get_cookie(request_url).unwrap_or_else(|| panic!("Error ao ler cookie"));
+    Client::builder()
+        .cookie_store(true)
+        // .cookie_provider(Arc::from(jar))
+        .build()
+        .unwrap()
+}
+
+#[cfg(test)]
+mod tests {
+    use std::env;
+
+    use super::*;
+    use httpmock::prelude::*;
+    use reqwest::multipart;
+    use serde_derive::{Deserialize, Serialize};
+    use serde_json::json;
+
+    #[derive(Deserialize)]
+    struct Response {
+        #[serde(rename = "resultCount")]
+        result_count: i32,
+    }
+
+    #[derive(Deserialize)]
+    #[serde(rename_all = "camelCase")]
+    struct AuthResponse {
+        status: String,
+    }
+
+    #[derive(Deserialize, Serialize)]
+    struct UpdateData {
+        status: String,
+        email: String,
+    }
+
+    #[derive(Deserialize)]
+    struct FileUploadResponse {
+        ok: bool,
+    }
+
+    #[derive(Serialize, Deserialize)]
+    struct FakeAuth {
+        client_id: String,
+        client_secret: String,
+        grant_type: String,
+    }
+
+    #[derive(Deserialize)]
+    struct VoidResult {}
+
+    #[tokio::test]
+    async fn test_http_post_success() {
+        let mut headers = HeaderMap::new();
+        headers.append("user-agent", "eitri".parse().unwrap());
+
+        let client_id = env::var("EITRI_CLI_CLIENT_ID").unwrap();
+        let client_secret = env::var("EITRI_CLI_CLIENT_SECRET").unwrap();
+
+        let data = FakeAuth {
+            client_id,
+            client_secret,
+            grant_type: String::from("client_credentials"),
+        };
+
+        match post::<AuthResponse, FakeAuth>(
+            "https://api.eitri.tech/blind-guardian-api/v1/o/auth",
+            data,
+            headers,
+        )
+        .await
+        {
+            Ok(result) => {
+                assert_eq!(result.status, "ACTIVE");
+            }
+            Err(error) => match error {
+                HttpError::HttpError(_, error) => {
+                    panic!("{}", error.message)
+                }
+                HttpError::Deserialize(error) => {
+                    panic!("{:?}", error)
+                }
+            },
+        }
+    }
+
+    #[tokio::test]
+    async fn test_http_post_form_data_success() {
+        let mut headers = HeaderMap::new();
+        headers.append("user-agent", "eitri".parse().unwrap());
+        headers.append(
+            "Workspace-Id",
+            "3c42595c-3da6-475f-a843-5f65cd1982e6".parse().unwrap(),
+        );
+
+        let form = multipart::Form::new();
+
+        let form = form.text("filepath", "src/views/Home.jsx");
+
+        let part = multipart::Part::bytes("export default function Home {}".as_bytes())
+            .file_name("Home")
+            .mime_str("text/plain");
+
+        let part_result = match part {
+            Ok(result) => result,
+            Err(_) => {
+                panic!("Erro ao construir part")
+            }
+        };
+        let form = form.part("file", part_result);
+
+        let server = MockServer::start();
+
+        server.mock(|when, then| {
+            when.method(POST).path("/runes-foundry/fileupload");
+            then.status(200)
+                .header("content-type", "application/json; charset=UTF-8")
+                .body(
+                    json!({
+                        "ok": true
+                    })
+                    .to_string()
+                    .as_bytes(),
+                );
+        });
+
+        match post_form_data::<FileUploadResponse>(
+            &server.url("/runes-foundry/fileupload"),
+            form,
+            headers,
+        )
+        .await
+        {
+            Ok(result) => {
+                assert!(result.ok);
+            }
+            Err(error) => match error {
+                HttpError::HttpError(_, error) => {
+                    panic!("{}", error.message)
+                }
+                HttpError::Deserialize(error) => {
+                    panic!("{:?}", error)
+                }
+            },
+        }
+    }
+
+    #[tokio::test]
+    async fn test_http_get_success() {
+        let mut headers = HeaderMap::new();
+        headers.append("user-agent", "eitri".parse().unwrap());
+        let result: Result<Response, HttpError> =
+            get("https://calindra.tech/eitri/product_list.json", headers).await;
+        assert!(result.is_ok());
+        let data = result.unwrap();
+        assert_eq!(6, data.result_count);
+    }
+
+    #[tokio::test]
+    async fn test_http_get_error_unauthorized() {
+        let mut headers = HeaderMap::new();
+        headers.append("user-agent", "eitri".parse().unwrap());
+
+        match get::<Response>(
+            "https://api.eitri.tech/eitri-manager-api/eitri-apps",
+            headers,
+        )
+        .await
+        {
+            Ok(_) => {}
+            Err(erro) => match erro {
+                HttpError::HttpError(status, error) => {
+                    assert_eq!(status, 401);
+                    assert_eq!(error.message, "JWT missing.")
+                }
+                HttpError::Deserialize(error) => {
+                    panic!("{:?}", error)
+                }
+            },
+        }
+    }
+
+    #[tokio::test]
+    async fn test_http_get_error_forbidden_with_xml_response() {
+        let mut headers = HeaderMap::new();
+        headers.append("user-agent", "eitri".parse().unwrap());
+        match get::<Response>("https://calindra.tech/eitri/product_listx.json", headers).await {
+            Ok(_) => {}
+            Err(erro) => match erro {
+                HttpError::HttpError(status, _) => {
+                    assert_eq!(status, 403)
+                }
+                HttpError::Deserialize(error) => {
+                    panic!("{:?}", error)
+                }
+            },
+        }
+    }
+
+    #[tokio::test]
+    async fn test_http_put_success() {
+        let mut headers = HeaderMap::new();
+        headers.append("user-agent", "eitri".parse().unwrap());
+
+        let email = String::from("foobar@mail.com");
+
+        let data = UpdateData {
+            status: String::from("ACTIVE"),
+            email,
+        };
+
+        let server = MockServer::start();
+
+        server.mock(|when, then| {
+            when.method(PUT).path("/blind-guardian-api/v1/p/users/self");
+            then.status(200)
+                .header("content-type", "application/json; charset=UTF-8")
+                .body(
+                    json!({
+                        "status": "ACTIVE",
+                        "email": "foobar@gmail.com"
+                    })
+                    .to_string()
+                    .as_bytes(),
+                );
+        });
+        match put::<UpdateData>(
+            &format!("{}/blind-guardian-api/v1/p/users/self", server.url("")),
+            data,
+            headers,
+        )
+        .await
+        {
+            Ok(_) => {}
+            Err(error) => match error {
+                HttpError::HttpError(_, error) => {
+                    panic!("{}", error.message)
+                }
+                HttpError::Deserialize(error) => {
+                    panic!("{:?}", error)
+                }
+            },
+        }
+    }
+
+    #[tokio::test]
+    async fn test_http_delete_success() {
+        let mut headers = HeaderMap::new();
+        headers.append("user-agent", "eitri".parse().unwrap());
+        headers.append(
+            "Workspace-Id",
+            "3c42595c-3da6-475f-a843-5f65cd1982e6".parse().unwrap(),
+        );
+        headers.append(
+            "Authorization",
+            "3c42595c-3da6-475f-a843-5f65cd1982e6".parse().unwrap(),
+        );
+
+        let server = MockServer::start();
+
+        server.mock(|when, then| {
+            when.method(DELETE).path("/runes-foundry/sources");
+            then.status(200)
+                .header("content-type", "application/json; charset=UTF-8")
+                .body(json!({}).to_string().as_bytes());
+        });
+
+        match delete(&server.url("/runes-foundry/sources"), headers).await {
+            Ok(_) => {}
+            Err(error) => match error {
+                HttpError::HttpError(_, error) => {
+                    panic!("{}", error.message)
+                }
+                HttpError::Deserialize(error) => {
+                    panic!("{:?}", error)
+                }
+            },
+        }
+    }
+
+    #[tokio::test]
+    async fn test_http_client_should_receive_cookies() {
+        let url = "https://api.eitri.tech/runes-foundry/health";
+        let client = get_client(url);
+
+        let response = client
+            .get(url)
+            .send()
+            .await
+            .unwrap_or_else(|_| panic!("Erro inesperado"));
+
+        let mut cookies = response.cookies();
+
+        let stick_cookie = cookies.find(|c| c.name() == "stick_runes_foundry").unwrap();
+
+        assert_eq!(stick_cookie.name(), "stick_runes_foundry");
+    }
+}

package/eitri-cli-v2/src/infra/mod.rs

@@ -0,0 +1,2 @@
+pub mod async_runtime;
+pub mod http_client;

package/eitri-cli-v2/src/lib.rs

@@ -0,0 +1,41 @@
+use std::process::exit;
+
+use neon::prelude::*;
+mod commands;
+mod config;
+mod infra;
+mod model;
+mod services;
+mod utils;
+fn publish(mut cx: FunctionContext) -> JsResult<JsPromise> {
+    let environment = match cx.argument::<JsString>(0) {
+        Ok(v) => v.value(&mut cx),
+        Err(_err) => {
+            eprintln!(
+                "É necessário passar como parâmetro o ID do environment para publicar a versão.",
+            );
+            exit(1);
+        }
+    };
+
+    let message = match cx.argument::<JsString>(1) {
+        Ok(v) => v.value(&mut cx),
+        Err(_err) => String::from(""),
+    };
+
+    let promise = commands::publish::execute(cx, environment, message);
+
+    match promise {
+        Ok(promise) => Ok(promise),
+        Err(_err) => {
+            eprintln!("Houve um erro inesperado ao executar o comando publish, por favor, tente novamente.");
+            exit(1)
+        }
+    }
+}
+
+#[neon::main]
+fn main(mut cx: ModuleContext) -> NeonResult<()> {
+    cx.export_function("publish", publish)?;
+    Ok(())
+}

package/eitri-cli-v2/src/model/auth_response.rs

@@ -0,0 +1,8 @@
+use serde::Deserialize;
+
+#[allow(dead_code)]
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AuthResponse {
+    pub access_token: String,
+}

package/eitri-cli-v2/src/model/credentials.rs

@@ -0,0 +1,8 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Credentials {
+    pub dev_user: String,
+    pub dev_key: String,
+}