eitri-cli 1.7.0-beta.4 → 1.7.0-beta.6

package/config/dev.js

@@ -100,6 +100,17 @@ const config = {
     eitriManager: {
         url: `https://${HOST}/eitri-manager-api`,
     },
+    cdn: {
+        library: {
+            url: "https://cdn.83io.com.br/library",
+            bifrost: {
+                versions: "/eitri-bifrost/versions/index.json"
+            },
+            luminusUi: {
+                versions: "/luminus-ui/versions/index.json"
+            },
+        }
+    }
 };
 
 module.exports = config;

package/config/k8s-eitri.js

@@ -84,6 +84,17 @@ const config = {
     },
     managerFront: {
         url: `https://admin.k8s.eitri.calindra.com.br`
+    },
+    cdn: {
+        library: {
+            url: "https://cdn.83io.com.br/library",
+            bifrost: {
+                versions: "/eitri-bifrost/versions/index.json"
+            },
+            luminusUi: {
+                versions: "/luminus-ui/versions/index.json"
+            },
+        }
     }
 }
 

package/config/loc-eitri.js

@@ -102,6 +102,17 @@ const config = {
         my: "/workspace/my",
         check: "/workspace/check",
     },
+    cdn: {
+        library: {
+            url: "https://cdn.83io.com.br/library",
+            bifrost: {
+                versions: "/eitri-bifrost/versions/index.json"
+            },
+            luminusUi: {
+                versions: "/luminus-ui/versions/index.json"
+            },
+        }
+    }
 };
 
 module.exports = config;

package/config/prod-eitri.js

@@ -103,6 +103,17 @@ const config = {
         my: "/workspace/my",
         check: "/workspace/check",
     },
+    cdn: {
+        library: {
+            url: "https://cdn.83io.com.br/library",
+            bifrost: {
+                versions: "/eitri-bifrost/versions/index.json"
+            },
+            luminusUi: {
+                versions: "/luminus-ui/versions/index.json"
+            },
+        }
+    }
 };
 
 module.exports = config;

package/index.js

@@ -114,6 +114,17 @@ const run = async () => {
             );
         });
 
+    program
+        .command("libs")
+        .description("Bibliotecas do Eitri")
+        .option(
+            "-l, --list",
+            "Lista as bibliotecas do Eitri com suas versões"
+        )
+        .action((cmdObj) => {
+            require("./src/cmd/eitriLibs")(cmdObj);
+        });
+
     program.addCommand(VegvisirCommand());
 
     if (

package/package.json

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

package/src/cmd/eitriLibs.js

@@ -0,0 +1,38 @@
+const {workspace} = require('../service/Workspace')
+const TrackingService = require('../service/TrackingService')
+const TrackingEitriAnalytics = require('../service/TrackingEitriAnalytics')
+const LibsService = require('../service/LibsService')
+
+const blindGuardian = workspace.blindGuardian
+const trackingService = new TrackingService(blindGuardian)
+
+module.exports = async function eitriLibs(cmdObj) {
+    if(cmdObj.list){
+        await listLibs()
+    }
+}
+
+async function listLibs() {
+    try {
+        const libsVersions = await LibsService.simultaneousRequestAndHandleData()
+        console.log("libsVersions", libsVersions)
+        TrackingEitriAnalytics.sendEvent({
+            eventName: "eitriLibs.listLibs",
+            userId: workspace?.userEmail,
+            data: libsVersions
+        })
+        process.exit(0)
+    } catch (e) {
+        TrackingEitriAnalytics.sendEvent({
+            eventName: "clean.error",
+            userId: workspace?.userEmail,
+            data: {
+                errorMessage: e?.message || ""
+            }
+        })
+
+
+        await trackingService.sendError(e)
+        process.exit(1)
+    }
+}

package/src/cmd/push-version.js

@@ -8,27 +8,19 @@ const config = require('../service/ConfigService')
 const TargetService = require('../service/TargetService')
 const inquirer = require('inquirer')
 const TrackingEitriAnalytics = require('../service/TrackingEitriAnalytics')
-const UserLocalCredential = require('../util/UserLocalCredential')
 const VegvisirService = require('../modules/vegvisir/VegvisirService')
 const {randomUUID} = require('crypto')
 const childProcess = require('child_process')
 const blindGuardian = workspace.blindGuardian
-const trackingService = new TrackingService(blindGuardian)
 const targetService = new TargetService(workspace)
 const vegvisirService = new VegvisirService()
-const standardVersion = require('standard-version')
 const releaseService = require('../service/ReleaseService')
 const {isGitRepo} = require('../util/GenericUtils')
-const debug = require('debug')('eitri:pushVersion')
+const PrerequisitesValidator = require('../service/PrerequisitesValidator')
+const prerequisitesValidator = new PrerequisitesValidator(workspace)
 
 module.exports = async function pushVersion(cmdObj) {
-    try {
-        UserLocalCredential.checkForCredentials()
-    } catch (error) {
-        const errorMessage = cmdObj?.verbose ? error : error?.message
-        console.error("\n", errorMessage, "\n")
-        return
-    }
+    prerequisitesValidator.checkCredentials()
 
     const {slug: miniConfSlug} = workspace.getMiniConf()
     await vegvisirService.isCurrentWorkspaceOwnedByUser(miniConfSlug)

package/src/cmd/start.js

@@ -9,13 +9,14 @@ const config = require('../service/ConfigService')
 const handleStartServer = require('../service/StarterService')
 const TrackingEitriAnalytics = require('../service/TrackingEitriAnalytics')
 const VegvisirService = require('../modules/vegvisir/VegvisirService')
-const UserLocalCredential = require('../util/UserLocalCredential')
+const PrerequisitesValidator = require('../service/PrerequisitesValidator')
 
 const blindGuardian = workspace.blindGuardian
 const hashFolder = workspace.hashFolder
 const trackingService = new TrackingService(blindGuardian, { ignoreCredentialError: true })
 const watcher = new Watcher(workspace, hashFolder, trackingService)
 const vegvisirService = new VegvisirService(workspace)
+const prerequisitesValidator = new PrerequisitesValidator(workspace)
 const debug = require('debug')('eitri:start')
 
 module.exports = async function start(args) {
@@ -27,15 +28,7 @@ module.exports = async function start(args) {
     const separator = '======================================================================='
     let displayFriendlyErrorAtEnd = ""
 
-    try {
-        UserLocalCredential.checkForCredentials()
-        debug("Successo na checagem de credenciais")
-    } catch (error) {
-        debug("ERRO na checagem de credenciais", {message: error?.message, error})
-        const errorMessage = args?.verbose ? error : error?.message
-        console.error("\n", errorMessage, "\n")
-        return
-    }
+    await prerequisitesValidator.checkAll()
 
     try {
         if (!args.force) {

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);
-            console.log("Construindo de", workspace.id)
+            console.log(`Construindo para o Workspace [${workspace.id}]`)
             workspace.id = validateUUID(this.workspaceId) ? this.workspaceId : workspace.id;
             return workspace;
         } catch (error) {

package/src/service/LibsService.js

@@ -0,0 +1,154 @@
+const axios = require('axios')
+const configService = require('./ConfigService')
+const CDN_83io_LIBRARY = configService.get('cdn')?.library
+const TrackingEitriAnalytics = require('./TrackingEitriAnalytics')
+
+class LibsService {
+
+    static async validateLibsVersions({libs = [], eitriAppConf = {}}) {
+        const {luminusUiVersion, bifrostVersion} = this.getEitriConfLibsVersions(libs)
+        if (!luminusUiVersion) {
+            throw new Error("Nenhuma versão do [luminus-ui/eitri-app-components] encontrada em seu eitri-app.conf");
+        }
+
+        if (!bifrostVersion) {
+            throw new Error("Nenhuma versão do [bifrost/eitri-app-client] encontrada em seu eitri-app.conf");
+        }
+
+        const {luminusUiVersions, bifrostVersions} = await this.simultaneousRequestAndHandleData();
+        const allBifrostVersions = bifrostVersions?.versions?.concat(bifrostVersions?.betaVersions, bifrostVersions?.alphaVersions);
+
+        const existsLuminus = luminusUiVersions?.versions?.some(version => version === luminusUiVersion);
+        if (!existsLuminus) {
+            this.throwNonExistentLibError({
+                libName: "luminus-ui/eitri-app-components",
+                eitriConfLibVersion: luminusUiVersion,
+                availableVersions: luminusUiVersions,
+                eitriAppConf,
+            });
+        }
+
+        const existsBifrost = allBifrostVersions.some(version => version === bifrostVersion);
+        if (!existsBifrost) {
+            this.throwNonExistentLibError({
+                libName: "bifrost/eitri-app-client",
+                eitriConfLibVersion: bifrostVersion,
+                availableVersions: allBifrostVersions,
+                eitriAppConf,
+            });
+        }
+
+    }
+
+    static getEitriConfLibsVersions(libs = []) {
+        const luminusUiNames = ["eitri-app-components", "eitri-luminus"];
+        const biFrostNames = ["eitri-app-client", "eitri-bifrost"];
+        const bifrostVersion = libs.find(lib => biFrostNames?.includes(lib.name))?.version;
+        const luminusUiVersion = libs.find(lib => luminusUiNames?.includes(lib.name))?.version;
+
+        return {
+            luminusUiVersion,
+            bifrostVersion
+        }
+    }
+
+    static async simultaneousRequestAndHandleData() {
+        const promises = await Promise.allSettled([
+            this.getBifrostVersions(), this.getLuminusUiVersions()
+        ]).then(res => res).catch(err => err)
+
+        const [bifrost, luminus] = promises;
+
+        let allBifrostVersions = {};
+        if (bifrost?.status === "fulfilled") {
+            allBifrostVersions = bifrost.value
+        }
+
+        let allLuminusVersions = {};
+        if (luminus?.status === "fulfilled") {
+            allLuminusVersions = luminus.value
+        }
+
+        return {
+            luminusUiVersions: allLuminusVersions,
+            bifrostVersions: allBifrostVersions
+        }
+    }
+
+    static handleRawDatas(promises = []) {
+
+        const [bifrost, luminus] = promises;
+
+        const allBifrostVersions = [];
+        if (bifrost?.status === "fulfilled") {
+            const versions = bifrost?.value?.versions?.concat(bifrost?.value?.betaVersions, bifrost?.value?.alphaVersions);
+            allBifrostVersions.push(...versions)
+        }
+
+        const allLuminusVersions = [];
+        if (luminus?.status === "fulfilled") {
+            allLuminusVersions.push(...luminus.value.versions)
+        }
+
+        return {
+            luminusUiVersions: allLuminusVersions,
+            bifrostVersions: allBifrostVersions,
+        }
+    }
+
+
+    static async getBifrostVersions() {
+        const fullUrl = `${CDN_83io_LIBRARY.url}${CDN_83io_LIBRARY.bifrost.versions}`;
+        try {
+            const response = await axios.get(fullUrl)
+            return response.data
+        } catch (error) {
+            const errorMessage = error?.message || "Erro na obtenção de versões do Bifrost"
+            this.sendErrorToAnalytics("getBifrostVersions", errorMessage)
+        }
+    }
+
+    static async getLuminusUiVersions() {
+        const fullUrl = `${CDN_83io_LIBRARY.url}${CDN_83io_LIBRARY.luminusUi.versions}`;
+        try {
+            const response = await axios.get(fullUrl)
+            return response.data
+        } catch (error) {
+            const errorMessage = error?.message || "Erro na obtenção de versões do LuminusUI"
+            this.sendErrorToAnalytics("getLuminusUiVersions", errorMessage)
+        }
+    }
+
+    static sendErrorToAnalytics(method = "", errorMessage = "") {
+        TrackingEitriAnalytics.sendEvent({
+            eventName: `${method}.error`,
+            userId: "",
+            data: {errorMessage}
+        })
+    }
+
+    static throwNonExistentLibError(input = {libName: "", eitriConfLibVersion: "", availableVersions: [], eitriAppConf: {}}) {
+        const {libName, eitriConfLibVersion, availableVersions, eitriAppConf} = input
+
+        const friendlyErrorMessage = `Versão da biblioteca [${libName}] não encontrada`;
+        console.log(`\n\x1b[1m\x1b[31m${friendlyErrorMessage}\x1b[0m\n`);
+        console.log("Veja as versões disponíveis abaixo e atualize o arquivo eitri-app.conf\n");
+        console.log(availableVersions)
+
+        TrackingEitriAnalytics.sendEvent({
+            eventName: "version.eitri-libs.not.found",
+            userId: "",
+            data: {
+                errorMessage: `Versão da biblioteca ${libName} não encontrada`,
+                eitriConfLibVersion,
+                availableVersions,
+                eitriAppConf,
+            }
+        })
+
+        process.exit(1)
+    }
+
+}
+
+module.exports = LibsService

package/src/service/PrerequisitesValidator.js

@@ -0,0 +1,84 @@
+const configService = require('./ConfigService')
+const UserLocalCredential = require('../util/UserLocalCredential');
+const Http = require('./Http');
+const TrackingEitriAnalytics = require('./TrackingEitriAnalytics');
+const MANAGER_URL = configService.get('eitriManager')?.url
+const {workspace} = require('../service/Workspace')
+const debug = require('debug')('eitri:PrerequisitesValidator')
+class PrerequisitesValidator {
+
+    constructor(workspace) {
+        this.workspace = workspace
+        this.blindGuardian = workspace.blindGuardian;
+        this.http = new Http(workspace.blindGuardian);
+        this.userInfo = {id: "", email: ""}
+    }
+
+    async checkAll() {
+        this.checkCredentials()
+        await this.isUserInOrg()
+    }
+
+    checkCredentials() {
+        try {
+            UserLocalCredential.checkForCredentials()
+            debug("Successo na checagem de credenciais")
+        } catch (error) {
+            this.sendErrorToAnalytics("checkCredentials.error", error)
+
+            debug("ERRO na checagem de credenciais", {message: error?.message, error})
+            console.error("\nError: ", {message: error?.message, error})
+            process.exit(1);
+        }
+    }
+
+    async isUserInOrg() {
+        const eitriAppConf = workspace.getMiniConf();
+
+        const respEitriAppData = await this.http.get(`${MANAGER_URL}/v2/eitri-apps/${eitriAppConf.id}`);
+        const respMyOrgsData = await this.http.get(`${MANAGER_URL}/users/me/organizations`);
+
+        const belongTo = respMyOrgsData?.some(org => org?.id === respEitriAppData?.organizationId)
+        const myOrgs = respMyOrgsData?.length > 0
+        if (myOrgs && belongTo) {
+            return
+        }
+
+        this.sendErrorToAnalytics("isUserInOrg.error", {confOrgId: respEitriAppData.organizationId, organizations: respMyOrgsData})
+
+        const friendlyErrorMessage = `Você ainda não foi registrado em nenhuma organização. Por favor, entre em contato com o administrador da sua organização.`
+        console.log(`\n\x1b[1m\x1b[31m ${friendlyErrorMessage} \x1b[0m\n`)
+        process.exit(1)
+    }
+
+    async getUserBasicInfo() {
+        if (this.userInfo.id && this.userInfo.email) {
+            return this.userInfo
+        }
+
+        const token = await this.blindGuardian.getToken().then(res => res).catch(_err => null)
+        this.userInfo = {
+            id: token?.id || "",
+            email: token?.email || ""
+        }
+        return {
+            id: token?.id || "",
+            email: token?.email || ""
+        }
+    }
+
+
+    sendErrorToAnalytics(eventName = "", data = {}) {
+        TrackingEitriAnalytics.sendEvent({
+            eventName,
+            userId: this.userInfo.id,
+            data: {
+                userData: this.userInfo,
+                ...data
+            }
+        }).catch(_err => null)
+    }
+
+}
+
+module.exports = PrerequisitesValidator

package/src/service/Workspace.js

@@ -29,6 +29,7 @@ const VegvisirService = require("../modules/vegvisir/VegvisirService");
 const HuginService = require("./HuginService");
 const EitriAppType = require("../model/EitriAppType");
 const chalk = require("chalk");
+const LibsService = require("./LibsService");
 const vegvisirService = new VegvisirService()
 const huginService = new HuginService()
 
@@ -207,6 +208,8 @@ class Workspace {
             await this.eitriAppService.writeEitriConf(remoteEitriConf, miniConf, this.folder2watch);
         }
 
+        await LibsService.validateLibsVersions({libs: state.libs, eitriAppConf: miniConf});
+
         this.printLibsVersion(state);
 
         await this.loadTarget(remoteTarget);
@@ -236,10 +239,10 @@ class Workspace {
                 if (m) {
                     version = m[1];
                 }
-                libVersionsOutput += `      ${lib.name} [${version}]\n`;
+                libVersionsOutput += `      ${lib.name} [${version}]`;
             }
         });
-        console.log(libVersionsOutput);
+        console.log("\n",libVersionsOutput, "\n");
     }
 
     async checkVersions() {

package/test/_fixtures/woodcoffee/miniapp.conf.js

@@ -1,5 +1,5 @@
 module.exports = {
     "version": "0.1.0",
-    "eitri-app-components": "0.0.1",
-    "eitri-app-client": "0.0.1"
+    "eitri-app-client":"1.0.0",
+    "eitri-app-components":"1.0.0"
 }

package/test/e2e/cli.test.js

@@ -212,6 +212,43 @@ describe("eitri-cli", () => {
         2 * minutes
     );
 
+    it(
+        "should list eitri libs versions",
+        async () => {
+            try {
+                await execAsync(
+                    `cd ${EITRI_WORK_DIR} && rm -rf ./eitri-test-*`,
+                    { env: process.env }
+                );
+
+                const executor = new Executor({env: devEnv});
+                await executor
+                    .exec("eitri libs -l")
+                    .waitFor(/libsVersions/);
+                await executor
+                    .exec("eitri libs -l")
+                    .waitFor(/luminusUiVersions/);
+                await executor
+                    .exec("eitri libs -l")
+                    .waitFor(/versions/);
+                await executor
+                    .exec("eitri libs -l")
+                    .waitFor(/bifrostVersions/);
+                await executor
+                    .exec("eitri libs -l")
+                    .waitFor(/betaVersions/);
+                await executor
+                    .exec("eitri libs -l")
+                    .waitFor(/alphaVersions/);
+
+            } catch (e) {
+                console.error(e);
+                throw e;
+            }
+        },
+        2 * minutes
+    );
+
     const getPublishedVersion = async (version, eitriAppId) => {
         const blindGuardian = new BlindGuardian();
         const http = new Http(blindGuardian);