eitri-cli 1.0.5 → 1.1.0-beta

package/src/service/factories/MiniWebAppFactory.js

@@ -1,9 +1,10 @@
 const fs = require('fs')
 const path = require('path')
-const WookCoffee = require('./WoodCoffeeFactory')
+const WoodCoffee = require('./WoodCoffeeFactory')
 const {getVersion} = require('../../cmd/version')
 
-class MiniWebAppFactory extends WookCoffee {
+// o MiniWebAppFactory nao eh um WoodCoffee :-(
+class MiniWebAppFactory extends WoodCoffee {
 
     async create(projectName, templateUrl) {
 
@@ -20,7 +21,7 @@ class MiniWebAppFactory extends WookCoffee {
         return { projectPath }
     }
 
-    writeAmeConf(project, conf, libsName) {
+    writeEitriAppConf(project, conf, libsName) {
         return new Promise((resolve, reject) => {
 
             libsName.forEach(libName => {

package/src/service/factories/WoodCoffeeFactory.js

@@ -1,156 +1,185 @@
-const fs = require('fs')
-const path = require('path')
-const AdmZip = require('adm-zip')
-const tmp = require('tmp')
-const util = require('util')
-const exec = util.promisify(require('child_process').exec)
-const rm = util.promisify(fs.rm)
-const { execSync } = require('child_process')
+const fs = require("fs");
+const path = require("path");
+const AdmZip = require("adm-zip");
+const tmp = require("tmp");
+const util = require("util");
+const exec = util.promisify(require("child_process").exec);
+const rm = util.promisify(fs.rm);
+const { execSync } = require("child_process");
 
 class WoodCoffee {
-    static COMPONENTS_LIBRARY_VERSION_HIGHLIGHTER = '###COMPONENTS_LIBRARY_VERSION_HIGHLIGHTER###'
-    static SUPER_APP_CLIENT_VERSION_HIGHLIGHTER = '###SUPER_APP_CLIENT_VERSION_HIGHLIGHTER###'
-    static SUPER_APP_CLIENT = 'eitri-app-client'
-    static MINIAPP_COMPONENTS = 'eitri-app-components'
+    static COMPONENTS_LIBRARY_VERSION_HIGHLIGHTER =
+        "###COMPONENTS_LIBRARY_VERSION_HIGHLIGHTER###";
+    static SUPER_APP_CLIENT_VERSION_HIGHLIGHTER =
+        "###SUPER_APP_CLIENT_VERSION_HIGHLIGHTER###";
+    static SUPER_APP_CLIENT = "eitri-app-client";
+    static MINIAPP_COMPONENTS = "eitri-app-components";
 
     async create(projectName, templateUrl, target) {
-        const projectPath = await this.verifyFolder(projectName)
-        let localPath
+        const projectPath = await this.verifyFolder(projectName);
+        let localPath;
 
-        if (process.env.LOG_LEVEL === 'full') {
-            console.log('Boilerplate localPath', localPath)
+        if (process.env.LOG_LEVEL === "full") {
+            console.log("Boilerplate localPath", localPath);
         }
-
-
         try {
-
             if (templateUrl) {
-                const projectStructure = await this.template(projectName, templateUrl, projectPath, target)
-                return { projectPath, structure: projectStructure }
+                const projectStructure = await this.template(
+                    projectName,
+                    templateUrl,
+                    projectPath,
+                    target
+                );
+                return { projectPath, structure: projectStructure };
             }
         } catch (error) {
-            if (error.message.includes('Command failed')) return await this.extractZip(localPath, projectPath)
-            console.error('Erro ao obter template', error)
+            if (error.message.includes("Command failed"))
+                return await this.extractZip(localPath, projectPath);
+            console.error("Erro ao obter template", error);
         }
-        return { projectPath }
+        return { projectPath };
     }
 
     /**
-     * 
+     *
      * @returns Objeto que representa a estrutura de diretorios do projeto criado
      */
     async template(projectName, templateUrl, projectPath, target) {
-        await this.downloadFromGithub(templateUrl, projectName, projectPath)
-        const aboutJsxPath = path.join(projectPath, 'src', 'views', 'About.jsx')
+        await this.downloadFromGithub(templateUrl, projectName, projectPath);
+        const aboutJsxPath = path.join(
+            projectPath,
+            "src",
+            "views",
+            "About.jsx"
+        );
 
-        const miniAppConf = require(path.join(projectPath, 'miniapp.conf.js'))
+        const miniAppConf = require(path.join(projectPath, "miniapp.conf.js"));
 
-        if(fs.existsSync(aboutJsxPath)) {
+        if (fs.existsSync(aboutJsxPath)) {
             try {
-
-
-                await this.checkAboutJsx(aboutJsxPath)
+                await this.checkAboutJsx(aboutJsxPath);
                 // TODO EITRI descomentar qd as libs forem pro npm
-                await this.updateAboutJSXFile(aboutJsxPath, miniAppConf)
+                await this.updateAboutJSXFile(aboutJsxPath, miniAppConf);
             } catch (e) {
                 // 'Usando template consistente para o About.jsx.'
-                const templateAboutJsxPath = path.join(path.dirname(__dirname), '..', 'util', 'AboutTemplate.jsx')
-                await this.copyFile(templateAboutJsxPath, aboutJsxPath)
+                const templateAboutJsxPath = path.join(
+                    path.dirname(__dirname),
+                    "..",
+                    "util",
+                    "AboutTemplate.jsx"
+                );
+                await this.copyFile(templateAboutJsxPath, aboutJsxPath);
                 // TODO EITRI descomentar qd as libs forem pro npm
-                await this.updateAboutJSXFile(aboutJsxPath, miniAppConf)
+                await this.updateAboutJSXFile(aboutJsxPath, miniAppConf);
             }
         }
-        
+
         return {
             src: { views: {} },
-            miniAppConf
-        }
+            miniAppConf,
+        };
     }
 
     async checkAboutJsx(aboutJsxPath) {
-        const contents = await this.getFile(aboutJsxPath)
-        if (!contents.includes(WoodCoffee.COMPONENTS_LIBRARY_VERSION_HIGHLIGHTER) || !contents.includes(WoodCoffee.SUPER_APP_CLIENT_VERSION_HIGHLIGHTER)) {
+        const contents = await this.getFile(aboutJsxPath);
+        if (
+            !contents.includes(
+                WoodCoffee.COMPONENTS_LIBRARY_VERSION_HIGHLIGHTER
+            ) ||
+            !contents.includes(WoodCoffee.SUPER_APP_CLIENT_VERSION_HIGHLIGHTER)
+        ) {
             // 'O arquivo About.jsx baixado, não é um arquivo consistente.'
-            throw new Error('Faltam placeholders para exibicao da versao do components e client')
+            throw new Error(
+                "Faltam placeholders para exibicao da versao do components e client"
+            );
         }
-        return true
+        return true;
     }
 
     async updateAboutJSXFile(aboutJsxPath, newMiniAppConf) {
-        const superAppClientLibVersion = newMiniAppConf[WoodCoffee.SUPER_APP_CLIENT]
-        const componentsLibVersion = newMiniAppConf[WoodCoffee.MINIAPP_COMPONENTS]
-        const contents = await this.getFile(aboutJsxPath)
+        const superAppClientLibVersion =
+            newMiniAppConf[WoodCoffee.SUPER_APP_CLIENT];
+        const componentsLibVersion =
+            newMiniAppConf[WoodCoffee.MINIAPP_COMPONENTS];
+        const contents = await this.getFile(aboutJsxPath);
         return new Promise((resolve, reject) => {
             const replaced = contents
-                .replace(WoodCoffee.COMPONENTS_LIBRARY_VERSION_HIGHLIGHTER, componentsLibVersion)
-                .replace(WoodCoffee.SUPER_APP_CLIENT_VERSION_HIGHLIGHTER, superAppClientLibVersion)
+                .replace(
+                    WoodCoffee.COMPONENTS_LIBRARY_VERSION_HIGHLIGHTER,
+                    componentsLibVersion
+                )
+                .replace(
+                    WoodCoffee.SUPER_APP_CLIENT_VERSION_HIGHLIGHTER,
+                    superAppClientLibVersion
+                );
 
-            fs.writeFile(aboutJsxPath, replaced, 'utf-8', function (err) {
+            fs.writeFile(aboutJsxPath, replaced, "utf-8", function (err) {
                 if (err) {
-                    console.error(err)
-                    reject(err)
+                    console.error(err);
+                    reject(err);
                 }
-                resolve()
-            })
-        })
+                resolve();
+            });
+        });
     }
 
     getFile(aboutJsxPath) {
         return new Promise((resolve, reject) => {
-            fs.readFile(aboutJsxPath, 'utf-8', function (err, contents) {
+            fs.readFile(aboutJsxPath, "utf-8", function (err, contents) {
                 if (err) {
-                    console.error(err)
-                    reject(err)
+                    console.error(err);
+                    reject(err);
                 }
-                resolve(contents)
-            })
-        })
+                resolve(contents);
+            });
+        });
     }
 
     async copyFile(currentPath, destinyPath) {
         return new Promise((resolve, reject) => {
             fs.copyFile(currentPath, destinyPath, (error) => {
                 if (error) {
-                    console.error(error)
-                    reject(error)
+                    console.error(error);
+                    reject(error);
                 }
-                resolve()
-            })
-        })
+                resolve();
+            });
+        });
     }
 
     validateFileName(folderName) {
-        const re = /[<>:"/\\|?*\x00-\x1F]|^(?:aux|con|clock\$|nul|prn|com[1-9]|lpt[1-9])$/i
+        const re =
+            /[<>:"/\\|?*\x00-\x1F]|^(?:aux|con|clock\$|nul|prn|com[1-9]|lpt[1-9])$/i;
         if (re.test(folderName)) {
-            return false
+            return false;
         }
-        return true
+        return true;
     }
 
     verifyFolder(projectName, options) {
-        options = options || {}
+        options = options || {};
         return new Promise((resolve, reject) => {
-            let projPath = process.cwd()
+            let projPath = process.cwd();
             if (!this.validateFileName(projectName)) {
                 return reject(
-                    `O nome do projeto ${projectName} possui caracteres proibidos.`,
-                )
+                    `O nome do projeto ${projectName} possui caracteres proibidos.`
+                );
             }
             if (projectName) {
-                projPath = path.join(process.cwd(), projectName)
+                projPath = path.join(process.cwd(), projectName);
             }
-            const folder2check = path.join(projPath, 'src')
+            const folder2check = path.join(projPath, "src");
             if (!options.supressLog) {
-                console.log('Verificando', folder2check)
+                console.log("Verificando", folder2check);
             }
             if (fs.existsSync(folder2check)) {
                 return reject(
-                    `A pasta ${folder2check} existe, abortando e deixando tudo inalterado.`,
-                )
+                    `A pasta ${folder2check} existe, abortando e deixando tudo inalterado.`
+                );
             }
 
-            resolve(projPath)
-        })
+            resolve(projPath);
+        });
     }
 
     extractZip(localPath, projectPath) {
@@ -160,71 +189,83 @@ class WoodCoffee {
                 /* overwrite*/ true,
                 (err) => {
                     if (err) {
-                        reject('Erro ao descompactar o boilerplate')
-                        console.log(err)
-                        return
+                        reject("Erro ao descompactar o boilerplate");
+                        console.log(err);
+                        return;
                     }
-                    console.log('Exemplo gerado.')
-                    resolve()
-                },
-            )
-        })
+                    console.log("Exemplo gerado.");
+                    resolve();
+                }
+            );
+        });
     }
 
     createTempFile() {
         return new Promise((resolve, reject) => {
-            tmp.file({ prefix: 'eitri-', postfix: '.zip', keep: true }, function (
-                err,
-                localPath,
-            ) {
-                if (err) {
-                    return reject(err)
+            tmp.file(
+                { prefix: "eitri-", postfix: ".zip", keep: true },
+                function (err, localPath) {
+                    if (err) {
+                        return reject(err);
+                    }
+                    resolve(localPath);
                 }
-                resolve(localPath)
-            })
-        })
+            );
+        });
     }
 
     downloadFromGithub(boilerplateUrl, projectName, projectPath) {
         return new Promise((resolve, reject) => {
-            const CMD = `git clone ${boilerplateUrl} ${projectName}`
+            const CMD = `git clone ${boilerplateUrl} ${projectName}`;
             exec(CMD, async (error, stdout, stderr) => {
                 if (error) {
-                    console.error('Não foi possível obter o template remoto. Resolvendo localmente.')
-                    return reject(error)
+                    console.error(
+                        "Não foi possível obter o template remoto. Resolvendo localmente."
+                    );
+                    return reject(error);
                 }
-                console.log('Download de template completo.')
-                Promise.resolve(rm(`${projectPath}/.git`, { recursive: true, force: true }))
-                resolve({ stdout: stdout, stderr: stderr })
-            })
-        })
-
+                console.log("Download de template completo.");
+                Promise.resolve(
+                    rm(`${projectPath}/.git`, { recursive: true, force: true })
+                );
+                resolve({ stdout: stdout, stderr: stderr });
+            });
+        });
     }
 
-    writeAmeConf(project, conf) {
+    writeEitriAppConf(project, conf) {
         return new Promise((resolve, reject) => {
-
-            conf['version'] = '0.1.0'
-            let confString = `module.exports = ${JSON.stringify(conf, null, 4)}`
-            fs.writeFile(path.join(project.projectPath, 'miniapp.conf.js'), confString, (err) => {
-                if (err) {
-                    return reject(err)
+            conf["version"] = "0.1.0";
+            let confString = `module.exports = ${JSON.stringify(
+                conf,
+                null,
+                4
+            )}`;
+            fs.writeFile(
+                path.join(project.projectPath, "miniapp.conf.js"),
+                confString,
+                (err) => {
+                    if (err) {
+                        return reject(err);
+                    }
+                    resolve();
                 }
-                resolve()
-            })
-        })
+            );
+        });
     }
 
     _getLatestLibVersion(libName) {
         try {
-            const cmd = `npm view ${libName} version`
-            const version = execSync(cmd).toString()
-            return version
+            const cmd = `npm view ${libName} version`;
+            const version = execSync(cmd).toString();
+            return version;
         } catch (error) {
-            console.error(`Não foi possível recuperar a última versão da biblioteca ${libName}.`)
-            throw error
+            console.error(
+                `Não foi possível recuperar a última versão da biblioteca ${libName}.`
+            );
+            throw error;
         }
     }
 }
 
-module.exports = WoodCoffee
+module.exports = WoodCoffee;

package/src/util/getCreateFactory.js

@@ -1,9 +1,9 @@
 const MiniWebAppFactory = require('../service/factories/MiniWebAppFactory')
-const WookCoffee = require('../service/factories/WoodCoffeeFactory')
+const WoodCoffee = require('../service/factories/WoodCoffeeFactory')
 
 module.exports = function getCreateFactory(platform) {
     if(platform === 'mobile') {
-        return new WookCoffee()
+        return new WoodCoffee()
     }
     return new MiniWebAppFactory()
 }

package/src/util/getWorkspace.js

@@ -0,0 +1,36 @@
+const { existsSync } = require("fs");
+const { readFile } = require("fs/promises");
+const path = require("path");
+const os = require("os");
+module.exports = async function getWorkspace() {
+    try {
+        const workspaceEitriAppProjectPath = path.resolve(
+            process.cwd(),
+            ".workspaces",
+            "workspace"
+        );
+    
+        if (existsSync(workspaceEitriAppProjectPath)) {
+            const fileContent = await readFile(
+                workspaceEitriAppProjectPath,
+                "utf8"
+            );
+            const workspace = JSON.parse(fileContent);
+            return workspace;
+        }
+        const workspaceGlobalPath = path.resolve(
+            os.homedir(),
+            ".eitri",
+            "workspaces",
+            "workspace"
+        );
+        const fileContent = await readFile(workspaceGlobalPath, "utf8");
+        const workspace = JSON.parse(fileContent);
+        return workspace;
+    } 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.")
+        }
+        throw new Error("Houve um erro inesperado ao tentar ler o workspace atual.")
+    }
+};

package/test/Factory.js

@@ -0,0 +1,13 @@
+module.exports = class Factory {
+    static generateWorkspace() {
+        return [
+            {
+                name: "MY_WORKSPACE",
+                userId: "2",
+                status: "ACTIVE",
+                id: "2a563ae3-722a-4640-8e7a-4f46aa93ec67",
+                createdAt: "2023-08-08T18:17:16.921Z",
+            },
+        ];
+    }
+};

package/test/modules/vegvisir/VegvisirService.test.js

@@ -0,0 +1,37 @@
+const VegvisirService = require("../../../src/modules/vegvisir/VegvisirService");
+const Factory = require("../../Factory");
+describe("Vegvisir Service Test", () => {
+    let vegvisirService = new VegvisirService();
+
+    beforeEach(() => {
+        vegvisirService = new VegvisirService();
+    });
+
+    it("should return error when user doesn't have workspace", async () => {
+        vegvisirService.http = {
+            get: () =>
+                Promise.reject({
+                    isAxiosError: true,
+                    response: {
+                        status: 404,
+                    },
+                }),
+        };
+        const consoleErrorSpy = jest.spyOn(console, "error");
+        await vegvisirService.listMyWorkspaces();
+
+        expect(consoleErrorSpy).toHaveBeenCalledWith(
+            "Você não possui workspaces cadastrados, utilize o comando 'eitri workspace create' para cadastrar"
+        );
+    });
+
+    it("should list all user workspaces", async () => {
+        vegvisirService.http = {
+            get: () => Promise.resolve(Factory.generateWorkspace()),
+        };
+        const result = await vegvisirService.listMyWorkspaces();
+
+        expect(result).toBeTruthy();
+        expect(result.length).toBeGreaterThan(0);
+    });
+});

package/test/utils/getWorkspaceId.test.js

@@ -0,0 +1,16 @@
+const getWorkspace = require("../../src/util/getWorkspace");
+const fs = require('fs/promises')
+
+
+jest.mock('fs', () => ({
+    existsSync: (path) => true
+}))
+
+describe('Get WorkspaceID Tests', () => {
+    
+    it('should return error if workspace file not found', async () => {
+        const promise = getWorkspace()
+        await expect(promise).rejects.toThrow("Você não tem nenhum workspace definido para desenvolvimento, execute o comando 'eitri workspace use' para definir um workspace.")
+    });
+
+});