eitri-cli 1.10.1-beta.1 → 1.10.1

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

@@ -0,0 +1,43 @@
+use serde_derive::{Deserialize, Serialize};
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct EitriConf {
+    #[serde(rename = "name")]
+    pub name: String,
+
+    #[serde(rename = "title")]
+    pub title: String,
+
+    #[serde(rename = "slug")]
+    pub slug: String,
+
+    #[serde(rename = "eitri-app-components")]
+    pub eitri_app_components: Option<String>,
+
+    #[serde(rename = "eitri-app-client")]
+    pub eitri_app_client: Option<String>,
+
+    #[serde(rename = "eitri-luminus")]
+    pub eitri_luminus: Option<String>,
+
+    #[serde(rename = "eitri-bifrost")]
+    pub eitri_bifrost: Option<String>,
+
+    #[serde(rename = "eitri-commons")]
+    pub eitri_commons: Option<String>,
+
+    #[serde(rename = "version")]
+    pub version: String,
+
+    #[serde(rename = "public-key")]
+    pub public_key: String,
+
+    #[serde(rename = "applicationId")]
+    pub application_id: String,
+
+    #[serde(rename = "id")]
+    pub id: String,
+
+    #[serde(rename = "organizationId")]
+    pub organization_id: String,
+}

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

@@ -0,0 +1,8 @@
+pub mod auth_response;
+pub mod credentials;
+pub mod eitri_conf;
+pub mod revision;
+pub mod process_output;
+pub mod test_config;
+pub mod workspace_auth;
+pub mod url;

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

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

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

@@ -0,0 +1,14 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Deserialize, Serialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct Revision {
+    pub id: String,
+
+    pub version: String,
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct GetRevisionsResult {
+    pub revisions: Vec<Revision>,
+}

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

@@ -0,0 +1,7 @@
+use serde::{Serialize, Deserialize};
+
+#[derive(Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TestConfig {
+    pub test_path: String
+}

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

@@ -0,0 +1,11 @@
+pub struct Url {
+    pub host: String,
+    pub path: String
+}
+
+impl Url {
+    pub fn get_full_url(&self) -> String{
+        let full_url = format!("{}{}", self.host, self.path);
+        full_url
+    }
+}

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

@@ -0,0 +1,4 @@
+pub struct WorkspaceAuth {
+    pub access_token: String,
+    pub user_workspace_id: String
+}

package/eitri-cli-v2/src/services/blind_guardian.rs

@@ -0,0 +1,87 @@
+use std::{env, process::exit};
+
+use reqwest::header::HeaderMap;
+use serde_derive::{Deserialize, Serialize};
+
+use crate::{
+    config::user_credentials,
+    infra::http_client::{self, HttpError},
+    model::{auth_response::AuthResponse, credentials::Credentials},
+};
+
+#[derive(Serialize, Deserialize)]
+struct AuthenticationDTO {
+    client_id: String,
+    client_secret: String,
+    grant_type: String,
+}
+
+#[allow(dead_code)]
+pub async fn get_access_token(host: &str, uri: &str) -> Result<String, HttpError> {
+    let mut headers = HeaderMap::new();
+    headers.append("user-agent", "eitri".parse().unwrap());
+
+    let client_id = env::var("EITRI_CLI_CLIENT_ID").unwrap_or_else(|_| String::from(""));
+    let client_secret = env::var("EITRI_CLI_CLIENT_SECRET").unwrap_or_else(|_| String::from(""));
+
+    let credentials = if !client_id.is_empty() && !client_secret.is_empty() {
+        let credentials = Credentials {
+            dev_key: client_secret,
+            dev_user: client_id,
+        };
+        credentials
+    } else {
+        let credentials = match user_credentials::get_credentials() {
+            Ok(credential) => credential,
+            Err(_) => {
+                eprintln!("Erro ao ler credenciais");
+                exit(1)
+            }
+        };
+        credentials
+    };
+
+    let data = AuthenticationDTO {
+        client_id: credentials.dev_user,
+        client_secret: credentials.dev_key,
+        grant_type: String::from("client_credentials"),
+    };
+
+    let url = &format!("{}/{}", host, uri);
+
+    let response = http_client::post::<AuthResponse, AuthenticationDTO>(url, data, headers).await?;
+
+    Ok(response.access_token)
+}
+
+#[cfg(test)]
+mod tests {
+
+    use super::*;
+    use httpmock::prelude::*;
+    use serde_json::json;
+
+    #[tokio::test]
+    async fn should_get_access_token() {
+        let server = MockServer::start();
+
+        server.mock(|when, then| {
+            when.method(POST).path("/blind-guardian-api/v2/o/auth");
+            then.status(200)
+                .header("content-type", "application/json; charset=UTF-8")
+                .body(
+                    json!({
+                        "accessToken": "123.123.123"
+                    })
+                    .to_string()
+                    .as_bytes(),
+                );
+        });
+
+        let token = get_access_token(&server.url(""), "blind-guardian-api/v2/o/auth")
+            .await
+            .unwrap();
+        
+        assert_eq!(token, "123.123.123")
+    }
+}

package/eitri-cli-v2/src/services/eitri_foundry.rs

@@ -0,0 +1,84 @@
+use crate::{
+  infra::http_client::{self, HttpError},
+  model::{
+    process_output::ProcessOutput, test_config::TestConfig, url::Url, workspace_auth::WorkspaceAuth,
+  },
+};
+
+pub async fn run_test(
+  workspace_auth: WorkspaceAuth,
+  test_path: String,
+  url: Url,
+) -> Result<ProcessOutput, HttpError> {
+  let access_token: String = workspace_auth.access_token;
+  let user_workspace_id: String = workspace_auth.user_workspace_id;
+  let mut headers = http_client::get_default_headers(access_token).await;
+  let url = url.get_full_url();
+  let data = TestConfig {
+    test_path: test_path,
+  };
+
+
+  headers.append("workspace-id", user_workspace_id.parse().unwrap());
+  let result = http_client::post::<ProcessOutput, TestConfig>(&url, data, headers).await?;
+
+  Ok(result)
+}
+
+#[cfg(test)]
+mod tests {
+  use httpmock::prelude::*;
+  use serde_json::json;
+
+  use crate::{
+    model::{url::Url, workspace_auth::WorkspaceAuth},
+    services::eitri_foundry::run_test,
+  };
+
+  #[tokio::test]
+  async fn should_return_test_status() {
+    let server = MockServer::start();
+
+    let result = String::from("'PASS ../storage/ad24ec72-90b0-4511-b836-e217183e31c7/react-proj/src/test/Service.test.js\n' +
+    '  ✓ teste soma agora (2 ms)\n' +
+    '  ✓ teste multiplicao agora\n' +
+    '\n' +
+    'Test Suites: 1 passed, 1 total\n' +
+    'Tests:       2 passed, 2 total\n' +
+    'Snapshots:   0 total\n' +
+    'Time:        0.162 s, estimated 1 s\n' +
+    'Ran all test suites'");
+
+    let mock = server.mock(|when, then| {
+      when.method(POST).path("/runes-foundry/run-test");
+      then
+        .status(200)
+        .header("content-type", "application/json; charset=UTF-8")
+        .body(
+          json!({
+              "stderr": result,
+              "stdout":"aaaaaa"
+          })
+          .to_string()
+          .as_bytes(),
+        );
+    });
+
+    let workspace_auth = WorkspaceAuth {
+      access_token: String::from("123.123.123"),
+      user_workspace_id: String::from("xxxx"),
+    };
+
+    let path = String::from("");
+    let url = Url {
+      host: server.url(""),
+      path: String::from("/runes-foundry/run-test"),
+    };
+
+    let response = run_test(workspace_auth, path, url).await.unwrap();
+
+    assert_eq!(mock.hits(), 1);
+    assert_eq!(response.stderr, result);
+
+  }
+}

package/eitri-cli-v2/src/services/eitri_manager.rs

@@ -0,0 +1,78 @@
+use std::process::exit;
+
+use serde_json::json;
+
+use crate::{
+    infra::http_client::{self, HttpError},
+    model::revision::{GetRevisionsResult, Revision},
+};
+
+use super::blind_guardian;
+
+pub async fn get_revision(eitri_app_id: &str, version: &str) -> Result<Revision, HttpError> {
+    let access_token = match blind_guardian::get_access_token(
+        "https://api.eitri.tech",
+        "blind-guardian-api/v2/o/auth",
+    )
+    .await
+    {
+        Ok(token) => token,
+        Err(_err) => {
+            eprintln!("Houve um erro ao autenticar-se no Eitri");
+            exit(1)
+        }
+    };
+
+    let headers = http_client::get_default_headers(access_token).await;
+
+    let url = format!(
+        "https://api.eitri.tech/eitri-manager-api/v2/revisions?eitriAppId={}&version={}",
+        eitri_app_id, version
+    );
+
+    let result = http_client::get::<GetRevisionsResult>(&url, headers).await?;
+
+    let revision = match result.revisions.first() {
+        Some(revision) => revision.clone(),
+        None => {
+            eprintln!("Versão não encontrada, certifique-se de que foi feito push-version antes de publicar a versão.");
+            exit(1)
+        }
+    };
+    Ok(revision)
+}
+
+pub async fn publish_revision(
+    eitri_app_id: &str,
+    environment_id: &str,
+    message: &str,
+) -> Result<String, HttpError> {
+    let access_token = match blind_guardian::get_access_token(
+        "https://api.eitri.tech",
+        "blind-guardian-api/v2/o/auth",
+    )
+    .await
+    {
+        Ok(token) => token,
+        Err(_err) => {
+            eprintln!("Houve um erro ao autenticar-se no Eitri");
+            exit(1)
+        }
+    };
+
+    let headers = http_client::get_default_headers(access_token).await;
+
+    let url = format!(
+        "https://api.eitri.tech/eitri-manager-api/revisions/{}/publish",
+        eitri_app_id
+    );
+
+    let data = json!({
+        "envId": environment_id,
+        "message": message
+    });
+
+    let result = http_client::put(&url, data, headers).await?;
+
+    Ok(result)
+}

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

@@ -0,0 +1,4 @@
+pub mod blind_guardian;
+pub mod eitri_manager;
+pub mod workspace;
+pub mod eitri_foundry;

package/eitri-cli-v2/src/services/workspace.rs

@@ -0,0 +1,49 @@
+use std::{env, fs, path::Path, process::exit};
+
+use crate::model::eitri_conf::EitriConf;
+use crate::utils::convert_eitri_conf;
+
+pub async fn read_eitri_conf() -> EitriConf {
+    let current_dir = match env::current_dir().ok() {
+        Some(it) => it,
+        None => {
+            eprintln!("Houve um erro o tentar ler o diretório atual");
+            exit(1)
+        }
+    };
+
+    let current_dir_str = current_dir.display().to_string();
+    let file_path = Path::new(&current_dir_str);
+    let file_path = file_path.join("eitri-app.conf.json");
+
+    convert_eitri_conf::convert();
+
+    let content = match fs::read_to_string(file_path.display().to_string()).ok() {
+        Some(it) => it,
+        None => {
+            eprintln!("Houve um erro ao tentar ler o eitri-app.conf do projeto. Certifique-se de estar no diretório de um Eitri-App");
+            exit(1)
+        }
+    };
+
+    let eitri_conf: EitriConf = match serde_json::from_str(&content).ok() {
+        Some(it) => {
+            match fs::remove_file(file_path.display().to_string()) {
+                Ok(()) => (),
+                Err(_err) => {
+                    eprintln!(
+                        "Houve um erro ao tentar ler o eitri-app.conf do projeto. Tente novamente."
+                    );
+                    exit(1)
+                }
+            };
+            it
+        }
+        None => {
+            eprintln!("Houve um erro ao fazer parse do json");
+            exit(1)
+        }
+    };
+
+    eitri_conf
+}

package/eitri-cli-v2/src/utils/convert_eitri_conf.rs

@@ -0,0 +1,98 @@
+use std::env::current_dir;
+use std::fs;
+use std::io::Write;
+use std::process::exit;
+use std::{fs::File, process::Command};
+
+static BASH_SCRIPT: &str = r#"
+#!/bin/bash
+
+# Atribua os argumentos a variáveis
+js_file="eitri-app.conf.js"
+json_file="eitri-app.conf.json"
+
+# Verifique se o arquivo JavaScript existe
+if [ ! -f "$js_file" ]; then
+    echo "Erro: Arquivo JavaScript não encontrado: $js_file"
+    exit 1
+fi
+
+# Execute o script JavaScript para converter o objeto para JSON e redirecione a saída para o arquivo JSON
+node -e "console.log(JSON.stringify(require('./$js_file'), null, 2))" > "$json_file"
+
+echo "Conversão concluída. O JSON foi salvo em: $json_file"
+"#;
+
+static BAT_SCRIPT: &str = r#"
+@echo off
+
+rem Atribua os argumentos a variáveis
+set "js_file=eitri-app.conf.js"
+set "json_file=eitri-app.conf.json"
+
+rem Verifique se o arquivo JavaScript existe
+if not exist "%js_file%" (
+    echo Erro: Arquivo JavaScript não encontrado: %js_file%
+    exit /b 1
+)
+
+rem Execute o script JavaScript para converter o objeto para JSON e redirecione a saída para o arquivo JSON
+node -e "console.log(JSON.stringify(require('./%js_file%'), null, 2))" > "%json_file%"
+
+echo Conversão concluída. O JSON foi salvo em: %json_file%
+"#;
+
+#[allow(dead_code)]
+pub fn convert() {
+    if cfg!(target_os = "windows") {
+        let temp_script = temp_bat_script();
+        println!("{temp_script}");
+        let out = Command::new("cmd")
+            .args(&["/C", &temp_script])
+            .output()
+            .expect("Falha ao converter arquivo .js e .json");
+        println!("\x1b[33mArquivo eitri-app.conf.json gerado com sucesso\x1b[0m");
+        match fs::remove_file(temp_script) {
+            Ok(it) => it,
+            Err(_err) => {
+                eprintln!("Houve um remover script temporário");
+                exit(1)
+            }
+        };
+        out
+    } else {
+        Command::new("sh")
+            .arg("-c")
+            .arg(BASH_SCRIPT)
+            .output()
+            .expect("Falha ao converter arquivo .js e .json")
+    };
+}
+
+fn temp_bat_script() -> String {
+    let dir = match current_dir() {
+        Ok(dir_path) => dir_path,
+        Err(_) => {
+            eprintln!("Houve um erro o tentar ler o diretório atual");
+            exit(1)
+        }
+    };
+
+    let file_path = dir.join("convert.bat");
+    let file = match File::create(file_path.to_owned()) {
+        Ok(it) => it,
+        Err(_err) => {
+            eprintln!("Houve um criar script temporário");
+            exit(1)
+        }
+    };
+    match writeln!(&file, "{BAT_SCRIPT}") {
+        Ok(it) => it,
+        Err(_err) => {
+            eprintln!("Houve um salvar script temporário");
+            exit(1)
+        }
+    };
+
+    file_path.to_owned().display().to_string()
+}

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eitri-cli",
-  "version": "1.10.1-beta.1",
+  "version": "1.10.1",
   "description": "Command Line Interface to make \"Eitri-App\" with code and fire.",
   "main": "index.js",
   "bin": {

package/src/modules/vegvisir/VegvisirService.js

@@ -125,7 +125,7 @@ module.exports = class VegvisirService {
             );
             const fileContent = await readFile(workspaceGlobalPath, "utf8");
             const workspace = JSON.parse(fileContent);
-            debug(`Construindo para o Workspace [${workspace.id} / Email: ${workspace.userEmail}]`)
+            debug(`Construindo para o Workspace [${workspace.id}]`)
             workspace.id = validateUUID(this.workspaceId) ? this.workspaceId : workspace.id;
             return workspace;
         } catch (error) {

package/src/service/Emulator/AndroidEmulatorService.js

@@ -2,7 +2,6 @@ const util = require('util');
 const inquirer = require("inquirer");
 const GenericUtils = require('../../util/GenericUtils');
 const exec = util.promisify(require("child_process").exec)
-const debug = require('debug')('eitri:AndroidEmulatorService')
 
 module.exports = class AndroidEmulatorService {
 
@@ -18,30 +17,9 @@ module.exports = class AndroidEmulatorService {
         try {
             console.log("Verificando instalação do ABD",)
             const command = "adb --version"
-            const {stdout} = await exec(command)
-            console.log("ADB Instalado. Continuando...\n");
-            
-            debug('checkHasInstalledAdb (adb --version):', stdout)
+            await exec(command)
+            console.log("ADB Instalado. Continuando...")
         } catch (error) {
-            console.error("checkHasInstalledAdb: Comando 'adb --version' não executado. Iniciando fallback. \n")
-            await this.checkHasInstalledAdbFallback(error)
-        }
-    }
-
-    static async checkHasInstalledAdbFallback(firstError = {}) {
-        try {
-            console.log("Verificação novamente instalação do ADB...");
-            
-            const command = "adb devices"
-            const {stdout} = await exec(command)
-            console.log("ADB Instalado. Continuando...\n");
-
-            debug('checkHasInstalledAdb (adb devices):', stdout)
-        } catch (fallbackError) {
-            console.error("checkHasInstalledAdb: Comando 'adb devices' não executado. \n")
-            console.error("\n\ncheckHasInstalledAdb error: 'adb --version': \n", {message: firstError?.message || "", error: firstError})
-            console.error("\n\ncheckHasInstalledAdb error: 'adb devices': \n", {message: fallbackError?.message || "", error: fallbackError})
-
             throw new Error('"adb" não instalado. Saiba mais em https://developer.android.com/tools/adb')
         }
     }
@@ -87,7 +65,7 @@ module.exports = class AndroidEmulatorService {
 
     static async openDeepLink(cmd) {
         try {
-            const { stderr } = await exec(cmd)
+            const {stderr} = await exec(cmd)
             return !(stderr);
         } catch (error) {
             console.log(`Houve um erro ao tentar abrir o Eitri-App via deep link`)

package/src/service/MiniLog.js

@@ -14,12 +14,12 @@ class MiniLog {
         return new Promise((resolve, reject) => {
             const socket = this.createSocket()
             socket.on('connect', () => {
-                if (!silentOnConnect) console.log('✓ Construindo para Workspace Temporário: ', roomName)
+                if(!silentOnConnect) console.log('✓ Construindo para Workspace Temporário: ', roomName)
                 socket.emit('joinRoom', roomName)
                 resolve()
             })
             socket.on('connect_error', (e) => {
-                if (silentOnConnect) console.error('Não foi possível contectar ao compilador', roomName)
+                if(silentOnConnect) console.error('Não foi possível contectar ao compilador', roomName)
                 else console.error('Não foi possível contectar ao compilador', roomName, `${this._config.url} ${this._config.path}`)
                 reject(e)
             })
@@ -29,6 +29,36 @@ class MiniLog {
             this.socket = socket
         })
     }
+    //TODO: ESSE MÉTODO DEVE SER APAGADO, QUANDO NÃO EXISTIR MAIS O COMANDO PUBLISH
+    awaitForPublish() {
+        return new Promise((resolve, reject) => {
+            this.socket.on('onLog', (event) => {
+                if (!event.publish) {
+                    return
+                }
+                if (event.publish.ok) {
+                    resolve(event)
+                } else {
+                    reject(new Error(event.publish.error))
+                }
+            })
+        })
+    }
+
+    awaitForBuild() {
+        return new Promise((resolve, reject) => {
+            this.socket.on('onLog', (event) => {
+                if (!event.publish) {
+                    return
+                }
+                if (event.publish.ok) {
+                    resolve(event)
+                } else {
+                    reject(new Error(event.publish.error))
+                }
+            })
+        })
+    }
 
     awaitForPushVersion() {
         return new Promise((resolve, reject) => {
@@ -39,8 +69,7 @@ class MiniLog {
                 if (event.publish.ok) {
                     resolve(event)
                 } else {
-                    console.error(event.publish.friendlyMessage || event.publish.error)
-                    return process.exit(1)
+                    reject(new Error(event.publish.error))
                 }
             })
         })
@@ -54,6 +83,18 @@ class MiniLog {
         }
     }
 
+    format2JSON(str) {
+        let parsedToJSON
+
+        try {
+            parsedToJSON = JSON.parse(str)
+        } catch (e) {
+            return undefined
+        }
+
+        return parsedToJSON
+    }
+
     printLog(data) {
         if (typeof data.msg === 'undefined') {
             return
@@ -80,7 +121,7 @@ class MiniLog {
             console.log(chalk.cyan(msg))
         } else {
             // A propriedade userFriendlyMessage deve ser tratada pelo Eitri-App. Logaremos da forma como o Eitri-App nos fornecer o objeto.
-            if (!data.method) {
+            if(!data.method) {
                 console.log(`\x1b[34meitri:\x1b[0m\x1b[97m${data.msg}\x1b[0m`);
             } else {
                 const message = this._colorizeMessage(data.msg, data.method)