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

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.5",
   "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/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/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);

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);