eitri-cli 1.0.4 → 1.1.0-beta

package/src/modules/vegvisir/VegvisirService.js

@@ -0,0 +1,71 @@
+const { default: axios } = require("../../../node_modules/axios/index");
+const BlindGuardian = require("../../service/BlindGuardian");
+const Http = require("../../service/Http");
+const config = require("config");
+const getWorkspace = require("../../util/getWorkspace");
+
+module.exports = class VegvisirService {
+    constructor() {
+        const blindGuardian = new BlindGuardian();
+        this.http = new Http(blindGuardian);
+        this.config = config.get("vegvisir");
+    }
+
+    async listMyWorkspaces() {
+        try {
+            const url = `${this.config.url}${this.config.basePath}${this.config.my}`;
+            const workspaces = await this.http.get(url);
+            return workspaces;
+        } catch (error) {
+            if (axios.isAxiosError(error)) {
+                if (error.response.status === 404) {
+                    console.error(
+                        "Você não possui workspaces cadastrados, utilize o comando 'eitri workspace create' para cadastrar"
+                    );
+                }
+            } else {
+                console.error("Houve um erro inesperado ao listar workspaces");
+            }
+        }
+    }
+
+    async create(createData) {
+        const url = `${this.config.url}${this.config.basePath}${this.config.workspace}`;
+        await this.http.post(url, createData);
+    }
+
+    async check(slug) {
+        try {
+            const workspace = await getWorkspace()
+            if(!workspace) {
+                console.log("É necessário ter um workspace definido para realizar essa ação, certifique-se de estar em um workspace.")
+                console.log("Execute o comando 'eitri workspace current' para checar você está em um workspace.")
+                return process.exit(0)
+            }
+
+            const data = {
+                slug,
+                id: workspace.id
+            }
+
+            const url =`${this.config.url}${this.config.basePath}${this.config.check}`;
+
+            await this.http.put(url, data)
+        } catch (error) {
+            console.error(error.message)
+            if (axios.isAxiosError(error)) {
+                if (error?.response?.status === 404) {
+                    console.error(
+                        "O Workspace atual não foi encontrado."
+                        );
+                        return process.exit(0)
+                    }
+                    console.error("Houve um erro inesperado ao listar workspaces");
+                return process.exit(0)
+                }
+            console.error(error.message)
+            return process.exit(0)
+        }
+
+    }
+};

package/src/modules/vegvisir/cmd/create.js

@@ -0,0 +1,43 @@
+const inquirer = require("inquirer");
+const VegvisirService = require("../VegvisirService");
+
+const NAME_REGEX = /^([a-zA-ZÀ-ú0-9\s]|_|\+|&|!)+$/;
+
+const vegvisirService = new VegvisirService();
+module.exports = async function create(cmdObj) {
+    console.log(
+        "\x1b[34mVamos criar o seu workspace. Para isso basta responder algumas perguntas:\x1b[0m"
+    );
+    const questions = createQuestions();
+
+    const res = await inquirer.prompt(questions);
+
+    const createData = {
+        name: res.name,
+    };
+    await vegvisirService.create(createData);
+    console.log(
+        "\n\x1b[34mWorkspace criado com sucesso! Para utilizá-lo basta executar o comando 'eitri workspace use' e selecionar seu novo workspace!\x1b[0m"
+    );
+};
+
+const nameValidate = (inpt) => {
+    if (!NAME_REGEX.test(inpt)) {
+        return "Não use caracteres especiais";
+    }
+    return true;
+};
+
+function createQuestions() {
+    return [
+        {
+            type: "input",
+            name: "name",
+            message: "Nome do Workspace (Ex: MY_WORKSPACE)",
+            validate: nameValidate,
+            default: () => {
+                return "DEFAULT";
+            },
+        },
+    ];
+}

package/src/modules/vegvisir/cmd/current.js

@@ -0,0 +1,20 @@
+const getWorkspace = require("../../../util/getWorkspace");
+
+module.exports = async function current(cmdObj) {
+    try {
+        const workspace = await getWorkspace()
+        console.log("====================================================")
+        console.log('\t Workspace Atual: ', workspace.name)
+        console.log("====================================================")
+    } catch (error) {
+        if (error.code === "ENOENT") {
+            throw new Error(
+                "Você não tem nenhum workspace definido para desenvolvimento, execute o comando 'eitri workspace use' para definir um workspace."
+            );
+        }
+        console.log(error)
+        throw new Error(
+            "Houve um erro inesperado ao tentar ler o workspace atual."
+        );
+    }
+};

package/src/modules/vegvisir/cmd/list.js

@@ -0,0 +1,13 @@
+const VegvisirService = require("../VegvisirService");
+
+const vegvisirService = new VegvisirService();
+module.exports = async function list(cmdObj) {
+    const workspaces = await vegvisirService.listMyWorkspaces();
+    if (!workspaces) return;
+    console.log("\n=======================================");
+    console.log("\tWorkspaces Disponíveis");
+    console.log("=======================================\n");
+    for (const workspace of workspaces) {
+        console.log("Workspace: ", workspace.name);
+    }
+};

package/src/modules/vegvisir/cmd/use.js

@@ -0,0 +1,71 @@
+const os = require("os");
+const inquirer = require("inquirer");
+const VegvisirService = require("../VegvisirService");
+const path = require("path");
+const { mkdir, writeFile } = require("fs/promises");
+const { existsSync } = require("fs");
+const vegvisirService = new VegvisirService();
+
+module.exports = async function use(cmdArgs) {
+    const workspaces = await vegvisirService.listMyWorkspaces();
+    if (!workspaces) return;
+
+    const { workspaceName } = await inquirer.prompt([
+        {
+            name: "workspaceName",
+            type: "rawlist",
+            message: "Selecione qual workspace você deseja utilizar:",
+            choices: workspaces,
+        },
+    ]);
+
+    const selectedWorkspace = workspaces.find(
+        (work) => work.name === workspaceName
+    );
+
+    if (cmdArgs.local) {
+        await writeLocalWorkspaceConfig(selectedWorkspace);
+        return;
+    }
+    await writeGlobalWorkspaceConfig(selectedWorkspace);
+};
+
+async function writeGlobalWorkspaceConfig(selectedWorkspace) {
+    const eitriFolderPath = path.resolve(os.homedir(), ".eitri");
+    const workspaceFolderPath = path.resolve(eitriFolderPath, "workspaces");
+    const workspaceFilePath = path.resolve(workspaceFolderPath, "workspace");
+
+    await mkdir(workspaceFolderPath, { recursive: true });
+
+    const workspaceConfig = JSON.stringify({
+        name: selectedWorkspace.name,
+        id: selectedWorkspace.id,
+    });
+
+    await writeFile(workspaceFilePath, workspaceConfig, { encoding: "utf8" });
+
+    console.log("\nWorkspace configurado com sucesso!");
+}
+
+async function writeLocalWorkspaceConfig(selectedWorkspace) {
+    const miniAppConfPath = path.resolve(process.cwd(), "miniapp.conf.js");
+    if (!existsSync(miniAppConfPath)) {
+        console.error(
+            "Você só pode selecionar um workspace como local dentro de um eitri-app"
+        );
+        return;
+    }
+    const workspaceFolderPath = path.resolve(process.cwd(), ".workspaces");
+    const workspaceFilePath = path.resolve(workspaceFolderPath, "workspace");
+
+    await mkdir(workspaceFolderPath, { recursive: true });
+
+    const workspaceConfig = JSON.stringify({
+        name: selectedWorkspace.name,
+        id: selectedWorkspace.id,
+    });
+
+    await writeFile(workspaceFilePath, workspaceConfig, { encoding: "utf8" });
+
+    console.log("\nWorkspace configurado com sucesso!");
+}

package/src/service/EitriAppManager.js

@@ -0,0 +1,32 @@
+const config = require('config')
+const Http = require("./Http")
+
+class EitriAppManager {
+    constructor(blindGuardian) {
+        this.http = new Http(blindGuardian)
+        this.config = config.get('eitriManager')
+        this.managerBaseURL = this.config.url
+    }
+
+    async findAllApplications() {
+        const url = `${this.managerBaseURL}/p/users/self/targets`
+        return await this.http.get(url)
+    }
+
+    async findApplicationById(applicationId) {
+        const url = `${this.managerBaseURL}/applications/${applicationId}`
+        return await this.http.get(url)
+    }
+
+    async create(eitriApp) {
+        const url = `${this.managerBaseURL}/eitri-apps`
+        try {
+            const res = await this.http.post(url, { ...eitriApp, publicKey: '', secretKey: '', status: 'ACTIVE' })
+            return res.data
+        } catch (e) {
+            Http.printLeanLogAxiosError(e)
+        }
+    }
+}
+
+module.exports = EitriAppManager

package/src/service/Http.js

@@ -6,6 +6,7 @@ const { v4: uuidv4 } = require('uuid')
 const os = require('os')
 const path = require('path')
 const getCliVersion = require('../util/getCliVersion')
+const getWorkspace = require('../util/getWorkspace')
 
 const filePath = path.join(os.homedir(), './.eitri.cookie.json')
 const jar = new CookieJar(new FileCookieStore(filePath))
@@ -20,13 +21,13 @@ axios.interceptors.response.use(function (response) {
     const YELLOW_COLOR = '\x1b[33m'
     const BLUE_COLOR = '\x1b[94m'
     const RESET_COLORS = '\x1b[0m'
-    const {warning} = response.data
-    const {greeting} = response.data
-    if(canShowLog) {
-        if(warning) {
+    const { warning } = response.data
+    const { greeting } = response.data
+    if (canShowLog) {
+        if (warning) {
             console.warn(`${YELLOW_COLOR}\nAtenção: ${warning.message}${YELLOW_COLOR}${RESET_COLORS}\n`)
         }
-        if(greeting) {
+        if (greeting) {
             console.log(`${BLUE_COLOR}\n${greeting.message}${BLUE_COLOR}${RESET_COLORS}\n`)
         }
         canShowLog = (warning || greeting) ? false : true
@@ -61,7 +62,7 @@ class Http {
             this.token = await this.tokenFactory.getToken()
         }
         const mergedHeaders = {
-            ...this._getHeader(), ...headers
+            ...(await this._getHeader(url)), ...headers
         }
         return await axios.post(url, data, { headers: mergedHeaders })
     }
@@ -72,19 +73,24 @@ class Http {
         }
 
         const headers = {
-            ...this._getHeader(),
+            ...(await this._getHeader(url)),
             'Content-Type': `multipart/form-data; boundary=${formData.getBoundary()}`,
         }
         return await this._postForm(url, formData, headers)
     }
 
-    _getHeader() {
+    async _getHeader(url) {
         const tid = uuidv4()
-        return {
+        const headers = {
             Authorization: `Bearer ${this.token.accessToken}`,
             'X-Transaction-Id': tid,
             'App-Tools-Version': getCliVersion()
         }
+        if (url.includes("foundry") || url.includes("runes-foundry")) {
+            headers["Workspace-Id"] = (await getWorkspace()).id;
+        }
+
+        return headers
     }
 
     __postForm(url, formData, headers, resolve, reject) {
@@ -103,7 +109,7 @@ class Http {
         if (!this.token) {
             this.token = await this.tokenFactory.getToken()
         }
-        const headers = this._getHeader()
+        const headers = await this._getHeader(url)
         return await this._delete(url, options, headers)
     }
 
@@ -124,7 +130,7 @@ class Http {
         if (!this.token) {
             this.token = await this.tokenFactory.getToken()
         }
-        const headers = this._getHeader()
+        const headers = await this._getHeader(url)
         return await this._get({ url, options, headers })
     }
 
@@ -135,7 +141,7 @@ class Http {
     }
 
     __get(args, resolve, reject) {
-        const mergedHeaders = { ...args.headers, ...args.options.headers} 
+        const mergedHeaders = { ...args.headers, ...args.options.headers }
         args.options.headers = mergedHeaders
         axios
             .get(args.url, args.options)
@@ -150,7 +156,7 @@ class Http {
                             .getToken()
                             .then((token) => {
                                 this.token = token
-                                args.headers = this._getHeader()
+                                args.headers = this._getHeader(args.url)
                                 this.__get(args, resolve, reject)
                             })
                             .catch(reject)
@@ -171,7 +177,7 @@ class Http {
         if (!this.token) {
             this.token = await this.tokenFactory.getToken()
         }
-        const mergedHeaders = { ...this._getHeader(), ...headers }
+        const mergedHeaders = { ...(await this._getHeader(url)), ...headers }
         return await this._put(url, data, mergedHeaders)
     }
 
@@ -229,6 +235,31 @@ class Http {
         headersCopy['Authorization'] = `Bearer ${token}`
         return headersCopy
     }
+
+    static printLeanLogAxiosError(e) {
+        const axios = require('axios')
+        if (axios.isAxiosError(e)) {
+            console.log(`AxiosError: ${JSON.stringify({
+                status: e.status,
+                config: {
+                    headers: e.config?.headers,
+                    method: e.config?.method,
+                    url: e.config?.url,
+                    data: Http.parseJson(e.config?.data),
+                },
+                responseData: e.response?.data,
+            }, null, 4)}`)
+        } else {
+            console.log(e)
+        }
+    }
+    static parseJson(data) {
+        try {
+            return JSON.parse(data ?? '{}')
+        } catch (e) {
+            return {}
+        }
+    }
 }
 
 module.exports = Http

package/src/service/Server.js

@@ -35,46 +35,22 @@ class Server {
     static startServer(args) {
         Server.stop(args)
         const { qrCodePath, qrPrinter, verbose } = args
-        const requestListener = function (req, res) {
-            if (req.url === '/') {
-                res.setHeader('Content-Type', 'text/html; charset=utf-8')
-                res.writeHead(200)
 
-                let readStream = fs.createReadStream(
-                    path.resolve(__dirname, '../view/index.html')
-                )
-                readStream.pipe(res)
-            } else {
-                res.setHeader('Content-Type', 'image/png')
-                res.writeHead(200)
-
-                let readStream = fs.createReadStream(qrCodePath)
-                readStream.pipe(res)
-            }
+        if (!qrPrinter && !process.env.AAT_QRCODE_PRINTER) {
+            open(qrCodePath)
+        } else if (qrPrinter && qrPrinter !== TERMINAL_PRINTER_NAME) {
+            open(qrCodePath, { app: qrPrinter })
+        } else if (
+            process.env.AAT_QRCODE_PRINTER &&
+            process.env.AAT_QRCODE_PRINTER !== TERMINAL_PRINTER_NAME
+        ) {
+            open(qrCodePath, {
+                app: process.env.AAT_QRCODE_PRINTER,
+            })
+        }
+        if (verbose) {
+            console.log(`Server is running on http://${host}:${port}`)
         }
-
-        serverInstance = Express().disable('x-powered-by')
-        serverInstance.use(expressRateLimiter)
-        serverInstance.use(requestListener)
-
-        serverInstance.listen(port, host, () => {
-            // Prioridade no printer informado pelo argumento do programa, depois o que foi informado na variavel de ambiente
-            if (!qrPrinter && !process.env.AAT_QRCODE_PRINTER) {
-                open(`http://${host}:${port}`)
-            } else if (qrPrinter && qrPrinter !== TERMINAL_PRINTER_NAME) {
-                open(`http://${host}:${port}`, { app: qrPrinter })
-            } else if (
-                process.env.AAT_QRCODE_PRINTER &&
-                process.env.AAT_QRCODE_PRINTER !== TERMINAL_PRINTER_NAME
-            ) {
-                open(`http://${host}:${port}`, {
-                    app: process.env.AAT_QRCODE_PRINTER,
-                })
-            }
-            if (verbose) {
-                console.log(`Server is running on http://${host}:${port}`)
-            }
-        })
     }
 
     static startServerMinhaContaEmulator(args) {