eitri-cli 1.10.1-beta.1 → 1.10.1

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

@@ -0,0 +1,2 @@
+pub mod publish;
+pub mod run_test;

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

@@ -0,0 +1,35 @@
+use std::process::exit;
+
+use crate::services::{eitri_manager, workspace};
+
+const DIVISOR: &str = "========================================================";
+
+pub async fn execute(environment: String, message: String) {
+  let init_message = format!("Iniciando publicação de Eitri-App",);
+  println!("{DIVISOR}");
+  println!("\t{init_message}");
+  println!("{DIVISOR}");
+
+  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)
+    }
+  }
+}

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

@@ -0,0 +1,41 @@
+use std::{env, process::exit};
+use colored::*;
+
+use crate::{
+  model::{url::Url, workspace_auth::WorkspaceAuth},
+  services::eitri_foundry,
+};
+
+pub async fn execute(_workspace_auth: WorkspaceAuth, _path: String) {
+  let path = env::var("FOUNDRY_CONTEXT_PATH")
+    .ok()
+    .and_then(|context_path| {
+      if context_path.is_empty() {
+        Some(String::from("foundry/run-test"))
+      } else {
+        Some(format!("{}/run-test", context_path))
+      }
+    })
+    .unwrap_or_else(|| String::from("foundry/run-test"));
+
+  let url = Url {
+    host: String::from("https://api.eitri.tech/"),
+    path: path,
+  };
+  let result = eitri_foundry::run_test(_workspace_auth, _path, url).await;
+
+  match result {
+    Ok(output) => {
+      let output_str = output.stderr;
+      eprint!("{output_str}");
+    }
+    Err(http_error) => {
+      if let Some(message) = http_error.get_message() {
+        eprintln!("{}", message.red().bold());
+      } else {
+        eprintln!("Houve um erro ao executar os testes.");
+      }
+      exit(1)
+    }
+  }
+}

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/http_client.rs

@@ -0,0 +1,493 @@
+// 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),
+}
+
+impl HttpError {
+    pub fn get_message(&self) -> Option<&String> {
+        match self {
+            HttpError::HttpError(_, api_error) => Some(&api_error.message),
+            _ => None,
+        }
+    }
+}
+
+#[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 @@
+pub mod http_client;

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

@@ -0,0 +1,30 @@
+#![deny(clippy::all)]
+
+use commands::{publish, run_test};
+use model::workspace_auth::WorkspaceAuth;
+mod commands;
+mod config;
+mod infra;
+mod model;
+mod services;
+mod utils;
+
+#[macro_use]
+extern crate napi_derive;
+
+#[napi]
+pub async fn publish(environment: String, message: String) {
+  publish::execute(environment, message).await;
+}
+
+#[napi]
+pub async fn run_test(user_jwt: String, user_workspace_id: String, test_path: String) {
+
+  let workspace_auth = WorkspaceAuth {
+    access_token: user_jwt,
+    user_workspace_id: user_workspace_id,
+  };
+  
+  run_test::execute(workspace_auth, test_path).await;
+
+}

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,
+}