eitri-cli 1.7.0-beta.3 → 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.3",
+  "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/cmd/start.js

@@ -7,7 +7,6 @@ const TrackingService = require('../service/TrackingService')
 const fs = require('fs')
 const config = require('../service/ConfigService')
 const handleStartServer = require('../service/StarterService')
-const inquirer = require('inquirer')
 const TrackingEitriAnalytics = require('../service/TrackingEitriAnalytics')
 const VegvisirService = require('../modules/vegvisir/VegvisirService')
 const UserLocalCredential = require('../util/UserLocalCredential')
@@ -59,20 +58,6 @@ module.exports = async function start(args) {
         debug("Informações do setupResult do workspace", {setupResult})
 
         const target = setupResult.target.name
-        
-        let targetConfig = {}
-
-        if(args.listTargetConfigs) {
-            await listTargetConfigs(target)
-            process.exit(1)
-        }
-
-        debug("Verificando se há targetConfig nos argumentos", {targetConfig: args?.targetConfig})
-        if(args.targetConfig) {
-            targetConfig = await askTargetConfig(args, target)
-        } else {
-            targetConfig = await getDefaultTargetConfig(target)
-        }
 
         blindGuardian.readConf()
         const qrCodeUrl = config.get('qrCode').url
@@ -126,8 +111,8 @@ module.exports = async function start(args) {
             ...args,
             deepLinks: loadedTarget?.deepLinks || []
         }
-        debug("Iniciando servidor", {argsWithDeeplinks, trackingService, watcher, workspace, target, targetConfig, platform})
-        await handleStartServer(argsWithDeeplinks, trackingService, watcher, workspace, target, targetConfig, platform)
+        debug("Iniciando servidor", {argsWithDeeplinks, trackingService, watcher, workspace, target, setupResult, platform})
+        await handleStartServer(argsWithDeeplinks, trackingService, watcher, workspace, target, setupResult, platform)
         debug("Servidor iniciado", {loadedTarget})
 
         TrackingEitriAnalytics.sendEvent({
@@ -177,34 +162,3 @@ module.exports = async function start(args) {
         }
     }
 }
-
-async function askTargetConfig(args, target) {
-    const availableConfigs = await workspace.getTargetConfig(args.targetConfig, target)
-
-    console.log(`Utilizando configuração: ${availableConfigs[0].id}`)
-    return availableConfigs[0]
-   
-}
-
-async function getDefaultTargetConfig(target) {
-    const configs = await workspace.getTargetConfig('default', target)
-    return configs[0]
-}
-
-async function listTargetConfigs(target) {
-    const availableConfigs = await workspace.getAllTargetConfigs(target)
-
-    const availableConfigsIds = availableConfigs.map(config => config.id)
-
-    const res = await inquirer.prompt([
-        {
-            name: 'accepted',
-            type: 'rawlist',
-            message: 'Configurações disponíveis:',
-            choices: availableConfigsIds
-        }
-    ]).then(input => input)
-
-    const config = availableConfigs.find(cfg => cfg.id === res.accepted)
-    console.log(`Utilize o comando --target-config ${config.id} para iniciar o Eitri-App com a configuração desejada`)
-}

package/src/model/Target.js

@@ -1,15 +1,4 @@
 /* eslint-disable no-unused-vars */
-class TargetConfig {
-    constructor() {
-        this.id = ''
-        this.libUrl = ''
-        this.runnerUrl = ''
-        this.bootstrapBaseUrl = ''
-        this.askUserDataApiUrl = ''
-        this.default = ''
-    }
-}
-
 class MiniAppBoilerplateList {
     constructor() {
         this.name = ''
@@ -57,10 +46,6 @@ module.exports = class Target {
         */
         this.platform= ''
         /**
-        *  @type {TargetConfig[]}
-        */
-        this.targetConfig= ''
-        /**
         * @type {string}
         */
         this.sdkSupport= ''

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/StarterService.js

@@ -4,7 +4,7 @@ const WebStarterFactory = require('./factories/WebStarterFactory')
 
 
 const strategy = require('./GATrackingStrategy')
-async function handleStartServer(args, trackingService, watcher, workspace, factoryName, targetConfig, platform) {
+async function handleStartServer(args, trackingService, watcher, workspace, factoryName, setupConfig, platform) {
     const factories = {
         mobile: new QRCodeStarterFactory(),
         web: new WebStarterFactory(),
@@ -24,7 +24,7 @@ async function handleStartServer(args, trackingService, watcher, workspace, fact
     }
 
 
-    const starter = await factory.create(args, trackingService, watcher, workspace, targetConfig)
+    const starter = await factory.create(args, trackingService, watcher, workspace, setupConfig)
     await starter.startServer()
 }
 

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()
 
@@ -93,49 +94,6 @@ class Workspace {
         return this.resourceFolders2watch;
     }
 
-
-    async getTargetConfig(id, target) {
-        try {
-            const configs = await this.getAllTargetConfigs(target);
-            const config = configs.find((cfg) => cfg.id === id);
-
-            if (!config) {
-                console.log(
-                    `TargetConfig [${target}] não encontrado, utilize o comando --list-target-configs para ver as configurações disponíveis`
-                );
-                process.exit(1);
-            }
-
-            return [config];
-        } catch (e) {
-            console.log(`Erro ao buscar configuração: ${e}`);
-            if (process.env.NODE_ENV !== 'test') {
-                process.exit(1);
-            }
-        }
-    }
-
-    async getAllTargetConfigs(applicationName) {
-        // const targetUrl = `${this.config.url}${this.config.targetPath}?name=${target}`
-        try {
-            // const response = await axios.get(targetUrl)
-            // const fullTarget = response.data
-
-            const targets = await this.availableTargets();
-            const fullTarget = targets.filter(
-                (a) => a.name === applicationName
-            );
-            const configs = fullTarget[0].targetConfig;
-
-            return configs;
-        } catch (e) {
-            console.log(`Erro ao buscar configuração: ${e}`);
-            if (process.env.NODE_ENV !== 'test') {
-                process.exit(1);
-            }
-        }
-    }
-
     getTarget() {
         if (!this.target) {
             console.warn("Target não foi detectado no setup()");
@@ -250,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);
@@ -357,51 +317,6 @@ class Workspace {
         return Base64.encode(JSON.stringify(miniAppData));
     }
 
-    async getWorkspaceURL(args, targetConfig) {
-        args = args || {};
-        const cookie = await this.http.getCookieSession(this.serverUrl);
-        let paramOrderId = "";
-        let paramShareId = "";
-        let cid;
-        const viewHtml = (args.view || "index") + ".html";
-        const miniAppConf = this.getMiniConf();
-        const data = {
-            publicKey: miniAppConf["public-key"],
-            metadata: miniAppConf["metadata"],
-            slug: miniAppConf["slug"],
-            title: miniAppConf["title"],
-        };
-        if (args.orderId) {
-            paramOrderId = "&orderId=" + encodeURIComponent(args.orderId);
-        }
-        if (args.shareId) {
-            paramShareId = "&shareId=" + encodeURIComponent(args.shareId);
-        }
-        if (args.initializationParams) {
-            data.initializationParams = args.initializationParams;
-        }
-        const encodedData = Base64.encode(JSON.stringify(data));
-        if (cookie) {
-            cid = Base64.encode(cookie.cookieString());
-        }
-
-        if (!targetConfig.bootstrapBaseUrl) {
-            throw new Error(
-                "Workspace.getWorkspaceURL.internalError#missingBootstrapBaseUrl"
-            );
-        }
-
-        let miniAppUrl = `${this.getBootstrapURL(
-            targetConfig.bootstrapBaseUrl
-        )}/${this.config.basePath || "workspace"
-            }/user/${(await vegvisirService.getWorkspace()).id}/${viewHtml}?data=${encodedData}${paramOrderId}${paramShareId}&devmode=true`;
-
-        if (cid) {
-            miniAppUrl = miniAppUrl + "&cid=" + cid;
-        }
-        return miniAppUrl;
-    }
-
     /**
      *
      * @param {string} bootstrapBaseUrl
@@ -419,13 +334,11 @@ class Workspace {
         return bootstrapBaseUrl;
     }
 
-    async getNewWorkspaceURL(args, targetConfig) {
-        const qrCodeConfig = await this.getQrCodeConfig(args, targetConfig);
+    async getNewWorkspaceURL(args, setupConfig) {
+        const qrCodeConfig = await this.getQrCodeConfig(args, setupConfig);
         const stateData = await this.saveShareState(qrCodeConfig);
         const stateId = stateData.id;
-        const miniAppUrl = `${this.qrCodeUrl}/${stateId}?environment=${(process.env.NODE_ENV === "hmlv2" ? "hml" : process.env.NODE_ENV) ||
-            "hml"
-            }`;
+        const miniAppUrl = `${this.qrCodeUrl}/${stateId}`;
         return {
             miniAppConf: {
                 ...qrCodeConfig,
@@ -448,7 +361,7 @@ class Workspace {
         return response.data;
     }
 
-    async getQrCodeConfig(args, targetConfig) {
+    async getQrCodeConfig(args, setupConfig) {
         args = args || {};
         const cookie = await this.http.getCookieSession(this.serverUrl);
         let cid;
@@ -468,10 +381,7 @@ class Workspace {
             slug: miniAppConf["slug"],
             title: miniAppConf["title"],
             permissions: miniAppConf["permissions"],
-
-            // Se nao enviarmos essa url pronta, o superapp tera que monta-la
-            // Essa url chama a funcao users.js do workspace-api
-            miniAppBootstrapUrl: await this.getWorkspaceURL(args, targetConfig),
+            miniAppBootstrapUrl: this.getBootstrapURL(setupConfig.eitriAppBootstrapURL),
             initializationParams,
             orderId,
             view,

package/src/service/factories/QRCodeStarterFactory.js

@@ -9,29 +9,20 @@ function QRCodeStarter(
     trackingService,
     watcher,
     workspace,
-    targetConfig
+    setupConfig
 ) {
     this.args = args;
     this.trackingService = trackingService;
     this.watcher = watcher;
     this.workspace = workspace;
-    this.targetConfig = targetConfig;
+    this.setupConfig = setupConfig;
 
     this.startServer = async function () {
-        let fullUrl;
-        if (this.args.oldQrcode) {
-            fullUrl = await this.workspace.getWorkspaceURL(
+        const workspaceURLConfig = await this.workspace.getNewWorkspaceURL(
                 this.args,
-                this.targetConfig
+                this.setupConfig
             );
-        } else {
-            const { miniAppUrl } = await this.workspace.getNewWorkspaceURL(
-                this.args,
-                this.targetConfig
-            );
-            fullUrl = miniAppUrl;
-        }
-
+        const fullUrl = workspaceURLConfig.miniAppUrl
         if (this.args.verbose) {
             console.log(`QrCodeUrl: ${fullUrl}`);
         }
@@ -130,14 +121,14 @@ function QRCodeContentFactory() {
         trackingService,
         watcher,
         workspace,
-        targetConfig
+        setupConfig
     ) {
         return new QRCodeStarter(
             args,
             trackingService,
             watcher,
             workspace,
-            targetConfig
+            setupConfig
         );
     };
 }

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

package/test/service/Workspace.test.js

@@ -131,126 +131,6 @@ describe('Workspace', () => {
             ])
         })
     })
-
-    describe('.getWorkspaceURL()', () => {
-        beforeEach(() => {
-            workspace.userEmail = 'dev@calindra.com.br'
-            workspace.target = {
-                bootstrapBaseUrl: 'http://minhaconta.base.url'
-            }
-            workspace.folder2watch = path.resolve(
-                __dirname,
-                '..',
-                '_fixtures',
-                'src'
-            )
-        })
-
-        it('retorna a url do workspace do usuario apontando para index.html', async () => {
-            let url = await workspace.getWorkspaceURL('', {bootstrapBaseUrl: 'http://minhaconta.base.url'})
-            expect(url).toContain('/index.html?')
-        })
-
-        it('Deve retornar queries string ', async () => {
-            let args = {
-                initializationParams: {
-                    foo: 'bar'
-                }
-            }
-            let urlValue = await workspace.getWorkspaceURL(args,  {bootstrapBaseUrl: 'http://minhaconta.base.url'})
-            console.log(urlValue)
-            let query = url.parse(urlValue, true).query
-            let dataString = Buffer.from(query.data, 'base64').toString()
-            let data = JSON.parse(dataString)
-            expect(data.initializationParams).toMatchObject(args.initializationParams)
-        })
-
-        it('retorna a url do workspace do usuario apontando para OrderDetails.html', async () => {
-            let url = await workspace.getWorkspaceURL({ view: 'OrderDetails' },  {bootstrapBaseUrl: 'http://minhaconta.base.url'})
-            expect(url).toContain('/OrderDetails.html?')
-        })
-
-        it('retorna a url do workspace do usuario com o parametro order id', async () => {
-            let url = await workspace.getWorkspaceURL({
-                view: 'OrderDetails',
-                orderId: 'e08a2547-b8d6-4437-91a7-0bc67987689d',
-            },  {bootstrapBaseUrl: 'http://minhaconta.base.url'})
-            expect(url).toContain(
-                'orderId=e08a2547-b8d6-4437-91a7-0bc67987689d'
-            )
-        })
-    })
-    describe('.getTargetConfig() & .getAllTargetConfigs()', () => {
-        const target = 'CALINDRA_MOBILE'
-        const res = [
-            {
-                id: 7,
-                name: 'CALINDRA_MOBILE',
-                minimumCliVersion: '1.16.5',
-                boilerplateUrl: 'https://github.com/Calindra/servless-backend-template.git',
-                superAppClientLibName: 'eitri-app-client',
-                componentsLibName: 'eitri-app-components',
-                description: 'CALINDRA_MOBILE',
-                status: 'ACTIVE',
-                platform: 'mobile',
-                targetConfig: [
-                    {
-                        id: 'default',
-                        libUrl: 'https://www.npmjs.com/package/eitri-app-client',
-                        runnerUrl: 'https://dev.eitri.calindra.com.br/app/',
-                        bootstrapBaseUrl: 'https://dev.eitri.calindra.com.br',
-                        askUserDataApiUrl: 'https://dev.eitri.calindra.com.br/miniapp-manager-api/o/mini-apps/:slug/token'
-                    },
-                    {
-                        id: 'ws',
-                        libUrl: 'https://www.npmjs.com/package/eitri-app-client',
-                        runnerUrl: 'https://dev.eitri.calindra.com.br/app/',
-                        bootstrapBaseUrl: 'http://localhost:3333',
-                        askUserDataApiUrl: 'https://dev.eitri.calindra.com.br/miniapp-manager-api/p/mini-apps/:slug/token/foundry'
-                    }
-                ],
-                default: true
-            }
-        ]
-
-        beforeEach(() => {
-            nock.cleanAll()
-            nock('https://dev.eitri.calindra.com.br')
-            .get(/\/eitri-manager-api\/p\/users\/self\/targets/).reply(200, res)
-        })
-
-        it('deve receber a configuração correta', async () => {
-            const config = await workspace.getTargetConfig('default', target)
-            expect(config[0]).toStrictEqual({
-                id: 'default',
-                libUrl: 'https://www.npmjs.com/package/eitri-app-client',
-                runnerUrl: 'https://dev.eitri.calindra.com.br/app/',
-                bootstrapBaseUrl: 'https://dev.eitri.calindra.com.br',
-                askUserDataApiUrl: 'https://dev.eitri.calindra.com.br/miniapp-manager-api/o/mini-apps/:slug/token'
-            })
-
-        }
-        )
-        it('deve retornar todos os configs', async () => {
-            const config = await workspace.getAllTargetConfigs(target)
-            expect(config).toMatchObject([
-                {
-                    id: 'default',
-                    libUrl: 'https://www.npmjs.com/package/eitri-app-client',
-                    runnerUrl: 'https://dev.eitri.calindra.com.br/app/',
-                    bootstrapBaseUrl: 'https://dev.eitri.calindra.com.br',
-                    askUserDataApiUrl: 'https://dev.eitri.calindra.com.br/miniapp-manager-api/o/mini-apps/:slug/token'
-                },
-                {
-                    id: 'ws',
-                    libUrl: 'https://www.npmjs.com/package/eitri-app-client',
-                    runnerUrl: 'https://dev.eitri.calindra.com.br/app/',
-                    bootstrapBaseUrl: 'http://localhost:3333',
-                    askUserDataApiUrl: 'https://dev.eitri.calindra.com.br/miniapp-manager-api/p/mini-apps/:slug/token/foundry'
-                }
-            ])
-        })  
-    })
     
     describe('.availableTargets()', () => {