eitri-cli 1.0.5 → 1.1.0-beta.1

package/src/cmd/create.js

@@ -1,197 +1,215 @@
-const Watcher = require('../service/Watcher')
-const inquirer = require('inquirer')
-const slugify = require('slugify')
-const config = require('config')
-const { Workspace } = require('../service/Workspace')
-const BlindGuardian = require('../service/BlindGuardian')
-const HashFolder = require('../service/HashFolder')
-const TrackingService = require('../service/TrackingService')
-const { NAME_TITLE_REGEX, SLUG_REGEX } = require('./validate')
-const handleStartServer = require('../service/StarterService')
-const getCreateFactory = require('../util/getCreateFactory')
-const UrlUtils = require('../util/UrlUtils')
+const Watcher = require("../service/Watcher");
+const inquirer = require("inquirer");
+const slugify = require("slugify");
+const config = require("config");
+const { Workspace } = require("../service/Workspace");
+const BlindGuardian = require("../service/BlindGuardian");
+const HashFolder = require("../service/HashFolder");
+const TrackingService = require("../service/TrackingService");
+const { NAME_TITLE_REGEX, SLUG_REGEX } = require("./validate");
+const handleStartServer = require("../service/StarterService");
+const getCreateFactory = require("../util/getCreateFactory");
+const UrlUtils = require("../util/UrlUtils");
 
 // eslint-disable-next-line no-unused-vars
-const Target = require('../model/Target')
-const TrackingEitriAnalytics = require('../service/TrackingEitriAnalytics')
+const Target = require("../model/Target");
+const EitriAppManager = require("../service/EitriAppManager");
+const WoodCoffee = require("../service/factories/WoodCoffeeFactory");
+const TrackingEitriAnalytics = require("../service/TrackingEitriAnalytics");
 
-const blindGuardian = new BlindGuardian()
-const hashFolder = new HashFolder()
-const workspace = new Workspace(blindGuardian, hashFolder)
-const trackingService = new TrackingService(blindGuardian, { ignoreCredentialError: true })
-const watcher = new Watcher(workspace, hashFolder, trackingService)
-const ITEM_DOUBT = 'DOUBTS'
+const blindGuardian = new BlindGuardian();
+const hashFolder = new HashFolder();
+const workspace = new Workspace(blindGuardian, hashFolder);
+const trackingService = new TrackingService(blindGuardian, {
+    ignoreCredentialError: true,
+});
+const watcher = new Watcher(workspace, hashFolder, trackingService);
+const ITEM_DOUBT = "DOUBTS";
+const eitriAppManager = new EitriAppManager(blindGuardian);
 
 const notBlank = (inpt) => {
     if (!inpt || !inpt.trim()) {
-        return 'Não pode ficar em branco'
+        return "Não pode ficar em branco";
     } else {
-        return true
+        return true;
     }
-}
+};
 
 const nameOrTitle = (inpt) => {
     if (!NAME_TITLE_REGEX.test(inpt)) {
-        return 'Não use caracteres especiais'
+        return "Não use caracteres especiais";
     }
-    return true
-}
+    return true;
+};
 
 const slug = (inpt) => {
     if (!SLUG_REGEX.test(inpt)) {
-        return 'Não use caracteres especiais'
+        return "Não use caracteres especiais";
     }
-    return true
-}
+    return true;
+};
 
 // eslint-disable-next-line no-unused-vars
 module.exports = async function create(projectName, cmdObj) {
-    console.log('\x1b[34mVamos criar o seu eitri-app. Para isso basta responder algumas perguntas:\x1b[0m');
+    console.log(
+        "\x1b[34mVamos criar o seu eitri-app. Para isso basta responder algumas perguntas:\x1b[0m"
+    );
 
     try {
-        const url = config.get('workspace').url
-        workspace.setServerUrl(url)
-        const platform = await askProjectPlatform()
-        if(platform.name === ITEM_DOUBT){
-            handleStartServer(cmdObj, trackingService, watcher, workspace, platform.name )
-            return
+        const url = config.get("workspace").url;
+        workspace.setServerUrl(url);
+        const clientApplication = await askClientApplication();
+        if (clientApplication.name === ITEM_DOUBT) {
+            handleStartServer(
+                cmdObj,
+                trackingService,
+                watcher,
+                workspace,
+                clientApplication.name
+            );
+            return;
         }
-        const res = await askProjMetadata(platform, cmdObj, projectName)
-        TrackingEitriAnalytics.sendEvent({
-            command: "create",
-            success: true,
-            data: {
-                projectName,
-                platform
-            }
-        })
-        return res
+        return await askProjMetadata(clientApplication, cmdObj, projectName);
     } catch (e) {
         await TrackingEitriAnalytics.sendEvent({
             command: "create",
             success: false,
-            errorMessage: e?.message
-        })
-        console.error(e?.message)
+            errorMessage: e?.message,
+        });
+        console.error(e?.message);
     }
-}
+};
 
-
-async function askProjectPlatform() {
-   
-    const defaultTarget = await workspace.getDefaultTarget();
-    const availableTargets = await workspace.availableTargets() || workspace.getKnownAvailableTargets()
-    if(availableTargets.length <= 0) {
-        console.log("Sua organização não contém nenhuma aplicação disponível para prosseguir com a criação.")
-        process.exit(0)
-    }
-    if (!availableTargets.length) {
-        return defaultTarget
+async function askClientApplication() {
+    const availableApplications = await eitriAppManager.findAllApplications();
+    if (availableApplications.length <= 0) {
+        console.log(
+            "Sua organização não contém nenhuma aplicação disponível para prosseguir com a criação."
+        );
+        process.exit(0);
     }
-    const cliOptions = [...availableTargets, { name: ITEM_DOUBT, label: 'Dúvidas? Veja documentação no browser'}]
+    const cliOptions = [
+        ...availableApplications,
+        { name: ITEM_DOUBT, label: "Dúvidas? Veja documentação no browser" },
+    ];
     const createLabel = (tgt) => {
-
-        let organizationLabel = tgt.organizationName || tgt.organizationId
-        if(tgt.organization) {
-            organizationLabel = tgt.organization.name || tgt.organization.id
-        }
-
-        return `${tgt.label || `${tgt.name} (${organizationLabel})`}`
-    }
+        const orgLabel = tgt.organization?.name ? `(${tgt.organization?.name})`: ''
+        return `${tgt.label || tgt.name} ${orgLabel}`;
+    };
 
     const res = await inquirer.prompt([
         {
-            name: 'accepted',
-            type: 'rawlist',
-            message: 'Selecione a aplicação para qual destina-se seu eitri-app:',
-            choices: cliOptions.map(createLabel)
-        }
-    ])
-    const target = cliOptions.find(tgt => createLabel(tgt) === res.accepted)
-    
-    target.onSelected && target.onSelected()
-    return target
+            name: "accepted",
+            type: "rawlist",
+            message:
+                "Selecione a aplicação para qual destina-se seu eitri-app:",
+            choices: cliOptions.map(createLabel),
+        },
+    ]);
+    const clientApplication = cliOptions.find(
+        (tgt) => createLabel(tgt) === res.accepted
+    );
+    clientApplication.onSelected && clientApplication.onSelected();
+    return clientApplication;
 }
 
-async function askProjMetadata(target, cmdObj, projectName) {
-    const factory = getCreateFactory(target.platform)
-    let questions = createQuestions(projectName)
+async function askProjMetadata(clientApplication, cmdObj, projectName) {
+    const factory = new WoodCoffee();
+    let questions = createQuestions(projectName);
     try {
-        await workspace.init()
+        await workspace.init();
     } catch (e) {
-        console.log(e.message)
-        return
+        console.log(e.message);
+        return;
     }
-    let answers
+    let answers;
     if (cmdObj.yes) {
         answers = {
             name: projectName,
             title: projectName,
-            slug: projectName
-        }
+            slug: projectName,
+        };
     } else {
-        answers = await inquirer.prompt(questions)
+        answers = await inquirer.prompt(questions);
     }
-    let conf = {...answers, organization: {id: target.organizationId}}
-    delete conf.organizationName
-    
-    let keepGoing = true
+    let conf = {
+        ...answers,
+        organization: { id: clientApplication.organizationId },
+    };
+    delete conf.organizationName;
+
+    let keepGoing = true;
     while (keepGoing) {
         try {
-            keepGoing = false
-            await factory.verifyFolder(projectName, {supressLog: true})
+            keepGoing = false;
+            await factory.verifyFolder(projectName, { supressLog: true });
 
             // Comentado até implementarmos os múltiplos boilerplates nos targets do banco
             //const {template} = cmdObj
 
-            const selectedTemplate = _getBoilerplateUrl(target, cmdObj)
+            const selectedTemplate = _getBoilerplateUrl(
+                clientApplication,
+                cmdObj
+            );
+            cmdObj.verbose &&
+                console.log(`Usando template ${selectedTemplate}`);
 
-            
-            cmdObj.verbose && console.log(`Usando template ${selectedTemplate}`)
-
-            let templateProject = await factory.create(projectName, selectedTemplate, target)
+            let templateProject = await factory.create(
+                projectName,
+                selectedTemplate,
+                clientApplication
+            );
 
             // conf sera usado pra escrever o arquivo miniapp.conf.js e nao queremos 'target' la.
-            const miniAppRequest = {...conf, target: target.name}
-            
-            // Cria no banco no final das configs locais
-            const miniApp = await workspace.create(miniAppRequest)
+            const eitriAppToCreate = {
+                ...conf,
+                organizationId: clientApplication.organization.id,
+                applicationId: clientApplication.id,
+            };
 
-            conf['public-key'] = miniApp.publicKey
+            // Cria no banco no final das configs locais
+            const eitriApp = await eitriAppManager.create(eitriAppToCreate);
+            conf["id"] = eitriApp.id;
+            conf["public-key"] = eitriApp.publicKey;
 
-            const templateMiniAppConf = templateProject.structure.miniAppConf
+            const templateEitriAppConf =
+                templateProject?.structure?.eitriAppConf;
 
             const finalConf = {
-                ...templateMiniAppConf,
-                ...conf    
-            }
-
-            await factory.writeAmeConf(templateProject, finalConf)
+                ...templateEitriAppConf,
+                ...conf,
+                organizationId: clientApplication.organization.id,
+                applicationId: clientApplication.id,
+            };
 
+            await factory.writeEitriAppConf(templateProject, finalConf);
         } catch (err) {
-            if(cmdObj.verbose) {
-                console.error('Houve uma falha durante a criação do eitri-app', err)
+            if (cmdObj.verbose) {
+                console.error(
+                    "Houve uma falha durante a criação do eitri-app",
+                    err
+                );
             }
 
             if (err.isDuplicatedError) {
                 if (cmdObj.yes) {
-                    process.exit(1)
+                    process.exit(1);
                 }
-                if (err.field === 'name') {
-                    keepGoing = true
-                    conf.name = await askName(projectName)
+                if (err.field === "name") {
+                    keepGoing = true;
+                    conf.name = await askName(projectName);
                 }
-                if (err.field === 'slug') {
-                    keepGoing = true
-                    conf.slug = await askSlug(projectName)
+                if (err.field === "slug") {
+                    keepGoing = true;
+                    conf.slug = await askSlug(projectName);
                 }
             } else {
                 if (err.isAxiosError) {
-                    console.log(err.response && err.response.status)
+                    console.log(err.response && err.response.status);
                 } else {
-                    console.log(err)
+                    console.log(err);
                 }
-                await trackingService.sendError(err)
+                await trackingService.sendError(err);
             }
         }
     }
@@ -200,82 +218,87 @@ async function askProjMetadata(target, cmdObj, projectName) {
 function createQuestions(projectName) {
     return [
         {
-            type: 'input',
-            name: 'name',
-            message: 'Digite um nome legível para seu eitri-app',
+            type: "input",
+            name: "name",
+            message: "Digite um nome legível para seu eitri-app",
             validate: nameOrTitle,
             default: () => {
-                return projectName
+                return projectName;
             },
         },
         {
-            type: 'input',
-            name: 'title',
-            message: 'Digite um nome para divulgação',
+            type: "input",
+            name: "title",
+            message: "Digite um nome para divulgação",
             validate: nameOrTitle,
             default: () => {
-                return projectName
+                return projectName;
             },
         },
         {
-            type: 'input',
-            name: 'slug',
-            message: 'Digite um nome único para seu eitri-app. Não pode conter espaços',
+            type: "input",
+            name: "slug",
+            message:
+                "Digite um nome único para seu eitri-app. Não pode conter espaços",
             default: (currentAnswers) => {
-                return slugify(currentAnswers.name).toLowerCase()
+                return slugify(currentAnswers.name).toLowerCase();
             },
             validate: slug,
-        }
-    ]
+        },
+    ];
 }
 
 async function askSlug(projectName) {
     let answer = await inquirer.prompt([
         {
-            type: 'input',
-            name: 'slug',
-            message: 'Outro nome único para o eitri-app:',
+            type: "input",
+            name: "slug",
+            message: "Outro nome único para o eitri-app:",
             validate: slug,
             default: () => {
-                return slugify(projectName).toLowerCase()
+                return slugify(projectName).toLowerCase();
             },
         },
-    ])
-    return answer.slug
+    ]);
+    return answer.slug;
 }
 
 async function askName(projectName) {
     let answer = await inquirer.prompt([
         {
-            type: 'input',
-            name: 'name',
-            message: 'Outro nome para o eitri-app:',
+            type: "input",
+            name: "name",
+            message: "Outro nome para o eitri-app:",
             validate: nameOrTitle,
             default: () => {
-                return projectName
+                return projectName;
             },
         },
-    ])
-    return answer.name
+    ]);
+    return answer.name;
 }
 
 /**
- * 
- * @param {Target} target 
- * @param {*} cmdObj 
+ *
+ * @param {Target} target
+ * @param {*} cmdObj
  */
 function _getBoilerplateUrl(target, cmdObj) {
-    const {template} = cmdObj
-    if(!template || !target.miniAppBoilerplateList) {
-        return target.boilerplateUrl
+    const { template } = cmdObj;
+    if (!template || !target.miniAppBoilerplateList) {
+        return target.boilerplateUrl;
     }
-    
-    const boilerplate = target.miniAppBoilerplateList.find(bp => bp.name === template)
 
-    if(!boilerplate) {
-        console.error(`O template [${template}] não existe para a aplicação que você selecionou.`)
-        return process.exit(0)
+    const boilerplate = target.miniAppBoilerplateList.find(
+        (bp) => bp.name === template
+    );
+
+    if (!boilerplate) {
+        console.error(
+            `O template [${template}] não existe para a aplicação que você selecionou.`
+        );
+        return process.exit(0);
     }
 
-    return boilerplate.boilerplateUrl
+    return boilerplate.boilerplateUrl;
 }

package/src/cmd/push-version.js

@@ -8,10 +8,13 @@ const config = require('../service/ConfigService')
 const TargetService = require('../service/TargetService')
 const inquirer = require('inquirer')
 const TrackingEitriAnalytics = require('../service/TrackingEitriAnalytics')
+const VegvisirService = require('../modules/vegvisir/VegvisirService')
+const getWorkspace = require('../util/getWorkspace')
 
 const blindGuardian = workspace.blindGuardian
 const trackingService = new TrackingService(blindGuardian)
 const targetService = new TargetService(workspace)
+const vegvisirService = new VegvisirService()
 
 module.exports = async function pushVersion(cmdObj) {
     try {
@@ -26,7 +29,9 @@ module.exports = async function pushVersion(cmdObj) {
             workspace.setResourceFolder2Watch(resourceFolders2watch)
         }
         workspace.publishing = true
-        let miniConf = workspace.getMiniConf()
+        const miniConf = workspace.getMiniConf()
+        await vegvisirService.check(miniConf.slug)
+
         let validateResult = checkErros(miniConf)
 
         if (!validateResult.isSuccess()) {
@@ -69,14 +74,18 @@ ${await targetService.getAppConfExampleSnippet()}
         workspace.setServerUrl(config.get('workspace').url)
         console.log('Conectando à forja de Eitri')
         await workspace.init()
-        await miniLog.connect(workspace.userEmail)
+        const userWorkspace = await getWorkspace()
+        await miniLog.connect(userWorkspace.id)
         console.log(separator)
         console.log('Analisando versões')
+        await workspace.checkVersions()
+
+        // Verificar se precisamos dessa parte
         const {target} = await workspace.checkVersions()
+        // const {addedPermissions, removedPermissions} = await workspace.comparePermissions(target)
+        // await logPermissionsAndOpenPrompt(addedPermissions, removedPermissions, cmdObj)
+        // console.log(separator)
 
-        const {addedPermissions, removedPermissions} = await workspace.comparePermissions(target)
-        await logPermissionsAndOpenPrompt(addedPermissions, removedPermissions, cmdObj)
-        console.log(separator)
         console.log('Preparando os arquivos do seu eitri-app')
 
         await workspace.uploadAll()
@@ -88,7 +97,7 @@ ${await targetService.getAppConfExampleSnippet()}
 
         const start = Date.now()
         let pushVersionPromise = miniLog.awaitForPushVersion()
-        await workspace.pushVersionAsJson(cmdObj.message)
+        await workspace.pushVersionAsJson(cmdObj)
         await pushVersionPromise
         console.log(separator)
         console.log('\x1b[1m\x1b[32mSucesso!!\x1b[0m');
@@ -136,15 +145,15 @@ function printAvailableWebhooks(webhooks) {
 }
 
 async function track(miniConf, start) {
-    let libs = await targetService.getLibs()
-    let event = {
-        superClientVersion: miniConf[libs.superAppClientLibName],
-        componentsVersion: miniConf[libs.componentsLibName],
-        miniAppSlug: miniConf.slug,
-        miniAppVersion: miniConf.version,
-        timeMs: Date.now() - start,
-    }
-    await trackingService.sendPushedVersion(event)
+    // let libs = await targetService.getLibs()
+    // let event = {
+    //     superClientVersion: miniConf[libs.superAppClientLibName],
+    //     componentsVersion: miniConf[libs.componentsLibName],
+    //     miniAppSlug: miniConf.slug,
+    //     miniAppVersion: miniConf.version,
+    //     timeMs: Date.now() - start,
+    // }
+    // await trackingService.sendPushedVersion(event)
 }
 
 function checkErros(miniConf) {

package/src/cmd/start.js

@@ -11,11 +11,14 @@ 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 getWorkspace = require('../util/getWorkspace')
 
 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()
 
 module.exports = async function start(args) {
     try {
@@ -32,6 +35,9 @@ module.exports = async function start(args) {
         if (fs.existsSync(resourceFolders2watch)) {
             workspace.setResourceFolder2Watch(resourceFolders2watch)
         }
+
+        const miniConf = workspace.getMiniConf()
+        await vegvisirService.check(miniConf.slug)
         
         const url = config.get('workspace').url
         const setupResult = await workspace.setup()
@@ -61,7 +67,8 @@ module.exports = async function start(args) {
         workspace.setQrCodeUrl(qrCodeUrl)
         await workspace.init()
         const silentOnConnect = args.verbose ? false : true
-        await miniLog.connect(workspace.userEmail, silentOnConnect)
+        const userWorkspace = await getWorkspace()
+        await miniLog.connect(userWorkspace.id, silentOnConnect)
 
         // TODO EITRI: descomentar apos publicacao das libs no npm
         // setupResult.state.libs.forEach(lib => {
@@ -140,10 +147,10 @@ module.exports = async function start(args) {
 }
 
 async function askTargetConfig(args, target) {
-    const avaiableConfigs = await workspace.getTargetConfig(args.targetConfig, target)
+    const availableConfigs = await workspace.getTargetConfig(args.targetConfig, target)
 
-    console.log(`Utilizando configuração: ${avaiableConfigs[0].id}`)
-    return avaiableConfigs[0]
+    console.log(`Utilizando configuração: ${availableConfigs[0].id}`)
+    return availableConfigs[0]
    
 }
 
@@ -153,19 +160,19 @@ async function getDefaultTargetConfig(target) {
 }
 
 async function listTargetConfigs(target) {
-    const avaiableConfigs = await workspace.getAllTargetConfigs(target)
+    const availableConfigs = await workspace.getAllTargetConfigs(target)
 
-    const avaiableConfigsIds = avaiableConfigs.map(config => config.id)
+    const availableConfigsIds = availableConfigs.map(config => config.id)
 
     const res = await inquirer.prompt([
         {
             name: 'accepted',
             type: 'rawlist',
             message: 'Configurações disponíveis:',
-            choices: avaiableConfigsIds
+            choices: availableConfigsIds
         }
     ]).then(input => input)
 
-    const config = avaiableConfigs.find(cfg => cfg.id === res.accepted)
+    const config = availableConfigs.find(cfg => cfg.id === res.accepted)
     console.log(`Utilize o comando --target-config ${config.id} para iniciar o miniapp com a configuração desejada`)
 }

package/src/modules/vegvisir/VegvisirCommand.js

@@ -0,0 +1,38 @@
+const commander = require("commander");
+
+module.exports = function VegvisirCommand() {
+    const workspaceCommand = commander.command("workspace");
+    workspaceCommand
+        .command("list")
+        .description("Lista os workspaces do usuário")
+        .action(async (cmdObj) => {
+            require("./cmd/list")(cmdObj);
+        });
+
+    workspaceCommand
+        .command("use")
+        .description("Seleciona qual workspace a ser utilizado")
+        .option(
+            "--local",
+            "Seleciona um workspace para um diretório de Eitri-App específico"
+        )
+        .action(async (cmdObj) => {
+            require("./cmd/use.js")(cmdObj);
+        });
+
+    workspaceCommand
+        .command("create")
+        .description("Cria um workspace para desenvolvimento de Eitri-Apps")
+        .action((cmdObj) => {
+            require("./cmd/create")(cmdObj);
+        });
+
+    workspaceCommand
+        .command("current")
+        .description("Exibe o workspace atual, obedecendo a prioridade Local > Global.")
+        .action((cmdObj) => {
+            require("./cmd/current")(cmdObj);
+        });
+
+    return workspaceCommand;
+};