eitri-cli 1.0.2

package/src/cmd/create.js

@@ -0,0 +1,281 @@
+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 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 notBlank = (inpt) => {
+    if (!inpt || !inpt.trim()) {
+        return 'Não pode ficar em branco'
+    } else {
+        return true
+    }
+}
+
+const nameOrTitle = (inpt) => {
+    if (!NAME_TITLE_REGEX.test(inpt)) {
+        return 'Não use caracteres especiais'
+    }
+    return true
+}
+
+const slug = (inpt) => {
+    if (!SLUG_REGEX.test(inpt)) {
+        return 'Não use caracteres especiais'
+    }
+    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');
+
+    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 res = await askProjMetadata(platform, cmdObj, projectName)
+        TrackingEitriAnalytics.sendEvent({
+            command: "create",
+            success: true,
+            data: {
+                projectName,
+                platform
+            }
+        })
+        return res
+    } catch (e) {
+        await TrackingEitriAnalytics.sendEvent({
+            command: "create",
+            success: false,
+            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
+    }
+    const cliOptions = [...availableTargets, { 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 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
+}
+
+async function askProjMetadata(target, cmdObj, projectName) {
+    const factory = getCreateFactory(target.platform)
+    let questions = createQuestions(projectName)
+    try {
+        await workspace.init()
+    } catch (e) {
+        console.log(e.message)
+        return
+    }
+    let answers
+    if (cmdObj.yes) {
+        answers = {
+            name: projectName,
+            title: projectName,
+            slug: projectName
+        }
+    } else {
+        answers = await inquirer.prompt(questions)
+    }
+    let conf = {...answers, organization: {id: target.organizationId}}
+    delete conf.organizationName
+    
+    let keepGoing = true
+    while (keepGoing) {
+        try {
+            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)
+
+            
+            cmdObj.verbose && console.log(`Usando template ${selectedTemplate}`)
+
+            let templateProject = await factory.create(projectName, selectedTemplate, target)
+
+            // 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)
+
+            conf['public-key'] = miniApp.publicKey
+
+            const templateMiniAppConf = templateProject.structure.miniAppConf
+
+            const finalConf = {
+                ...templateMiniAppConf,
+                ...conf    
+            }
+
+            await factory.writeAmeConf(templateProject, finalConf)
+
+        } catch (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)
+                }
+                if (err.field === 'name') {
+                    keepGoing = true
+                    conf.name = await askName(projectName)
+                }
+                if (err.field === 'slug') {
+                    keepGoing = true
+                    conf.slug = await askSlug(projectName)
+                }
+            } else {
+                if (err.isAxiosError) {
+                    console.log(err.response && err.response.status)
+                } else {
+                    console.log(err)
+                }
+                await trackingService.sendError(err)
+            }
+        }
+    }
+}
+
+function createQuestions(projectName) {
+    return [
+        {
+            type: 'input',
+            name: 'name',
+            message: 'Digite um nome legível para seu eitri-app',
+            validate: nameOrTitle,
+            default: () => {
+                return projectName
+            },
+        },
+        {
+            type: 'input',
+            name: 'title',
+            message: 'Digite um nome para divulgação',
+            validate: nameOrTitle,
+            default: () => {
+                return projectName
+            },
+        },
+        {
+            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()
+            },
+            validate: slug,
+        }
+    ]
+}
+
+async function askSlug(projectName) {
+    let answer = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'slug',
+            message: 'Outro nome único para o eitri-app:',
+            validate: slug,
+            default: () => {
+                return slugify(projectName).toLowerCase()
+            },
+        },
+    ])
+    return answer.slug
+}
+
+async function askName(projectName) {
+    let answer = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'name',
+            message: 'Outro nome para o eitri-app:',
+            validate: nameOrTitle,
+            default: () => {
+                return projectName
+            },
+        },
+    ])
+    return answer.name
+}
+
+/**
+ * 
+ * @param {Target} target 
+ * @param {*} cmdObj 
+ */
+function _getBoilerplateUrl(target, cmdObj) {
+    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)
+    }
+
+    return boilerplate.boilerplateUrl
+}

package/src/cmd/credentials.js

@@ -0,0 +1,105 @@
+const path = require('path')
+const { Workspace } = require('../service/Workspace')
+const BlindGuardian = require('../service/BlindGuardian')
+const CredentialsService = require('../service/CredentialsService')
+const validator = require('./validate')
+const TrackingService = require('../service/TrackingService')
+const HashFolder = require('../service/HashFolder')
+
+const blindGuardian = new BlindGuardian()
+const workspace = new Workspace(blindGuardian, new HashFolder())
+const credentialService = new CredentialsService(workspace)
+const trackingService = new TrackingService(blindGuardian, { ignoreCredentialError: true })
+
+const config = require('config')
+
+const credentialStrategies = {
+    [credentialService.upsert.name]: credentialService.upsert,
+    [credentialService.createApproval.name]: credentialService.createApproval
+}
+
+async function credentials(args) {
+    const theFunction = credentialStrategies[credentialService.upsert.name]
+    await doCredentials(args, theFunction.bind(credentialService))
+}
+
+async function askForApproval(args) {
+    const theFunction = credentialStrategies[credentialService.createApproval.name]
+    await doCredentials(args, theFunction.bind(credentialService))
+}
+
+async function doCredentials(args, strategy) {
+    try {
+
+        if(!strategy || strategy.constructor.name !== 'AsyncFunction') {
+            throw new Error(`Argumento strategy é invalido: ${strategy.name}`)
+        }
+
+        await assertNotRunning(args)
+
+        setupBlindGuardian()
+
+        await setupWorkspace(args)
+
+        await strategy(args)
+
+        console.log('Operacao realizada com sucesso.')
+    } catch (e) {
+        if (args.verbose) {
+            console.log('\n')
+            console.error(e)
+        } else if (e && e.response && e.response.data) {
+
+            const { data } = e.response
+            if( data.friendlyMessage) {
+                console.error(`ERRO: ${data.friendlyMessage}`)
+            } else if (data.message) {
+                console.error(`ERRO: ${data.message}`)
+            } else if (data.error) {
+                console.error(`ERRO: status: ${e.response.status} - ${data.error}`)
+            } else if (e.response.status === 500) {
+                console.error('ERRO: Erro interno')
+            } else {
+                console.error(`ERRO: ${e.response.status} - ${e.message} - ${data.error}`)
+            }
+        } else if (e && e.message) {
+            console.error(`ERRO: ${e.message}`)
+        } else {
+            console.error('Erro inesperado, tente novamente mais tarde.', e)
+        }
+
+        await trackingService.sendError(e)
+    }
+}
+
+async function assertNotRunning(args) {
+    if (!args.force) {
+        await validator.assertCommandNotRunning('credentials')
+    }
+}
+
+function setupBlindGuardian() {
+    blindGuardian.readConf()
+}
+
+async function setupWorkspace(args) {
+    const url = config.get('workspace').url
+    const qrCodeUrl = config.get('qrCode').url
+    if (args.verbose) {
+        console.log('WS url', url)
+        console.log('qrCodeUrl url', qrCodeUrl)
+    }
+
+    const folder2watch = path.join(process.cwd(), 'src')
+    workspace.setFolder2Watch(folder2watch)
+    workspace.setServerUrl(url)
+    workspace.setQrCodeUrl(qrCodeUrl)
+    await workspace.init()
+
+    let publicKey = workspace.getMiniConf()['public-key']
+    if (!publicKey) {
+        throw new Error('Vc nao possui [publicKey] no arquivo de configuração do projeto.')
+    }
+}
+
+module.exports = { credentials, askForApproval }

package/src/cmd/invite.js

@@ -0,0 +1,87 @@
+const emoji = require('emojilib')
+const inquirer = require('inquirer')
+const path = require('path')
+const {workspace} = require('../service/Workspace')
+const InviteService = require('../service/InviteService')
+const TrackingService = require('../service/TrackingService')
+const ErrorMessages = require('../util/error-messages/error-messages')
+const trackingService = new TrackingService(workspace.blindGuardian, { ignoreCredentialError: true })
+const inviteService = new InviteService(workspace)
+
+module.exports = async function invite(email, cmdObj) {
+    try {
+        const folder2watch = path.join(process.cwd(), 'src')
+        workspace.setFolder2Watch(folder2watch)
+        await workspace.init()
+        if (cmdObj.remove) {
+            let slug = workspace.getMiniConf().slug
+            let invites = await inviteService.findAllBySlug(slug)
+            let invite = invites.find(i => i.email === email)
+            if (!invite) {
+                console.log(`Convite inexistente para ${email} do miniapp ${slug}.`)
+                process.exit(1)
+            }
+            await inviteService.remove(invite)
+            console.log(`${email} removido com sucesso do miniapp ${slug}.`)
+        } else if (cmdObj.list) {
+            let slug = workspace.getMiniConf().slug
+            let invites = await inviteService.findAllBySlug(slug)
+            invites.forEach(invite => {
+                console.log(invite.email, '\t', invite.status)
+            })
+        } else if (cmdObj.accept) {
+            let invites = await inviteService.findAllPending()
+            if (!invites.length) {
+                console.log('Sem convites.')
+                process.exit(0)
+            }
+            console.log(`${invites.length} convites`)
+            const createLabel = (inv) => {
+                return `aceitar convite do miniapp "${inv.slug}" enviado por ${inv.inviterEmail || 'desconhecido'}`
+            }
+            let res = await inquirer.prompt([
+                {
+                    name: 'accepted',
+                    type: 'rawlist',
+                    message: 'Escolha:',
+                    choices: invites.map(createLabel).concat(['não aceitar nenhum convite'])
+                }
+            ])
+            let inviteToAccept = invites.find(inv => createLabel(inv) === res.accepted)
+            if (inviteToAccept) {
+                console.log(`Aceitando participar do miniapp ${inviteToAccept.slug}...`)
+                await inviteService.accept(inviteToAccept)
+                console.log(`Convite aceito! ${emoji.lib.clinking_glasses.char}`)
+            }
+        } else {
+            let slug = workspace.getMiniConf().slug
+            if (!email) {
+                console.log('Informe um email.')
+                process.exit(1)
+            }
+            await inviteService.sendInvite(slug, email)
+            console.log('Convite enviado com sucesso.')
+        }
+        process.exit(0)
+    } catch(e) {
+        if (cmdObj.verbose) {
+            console.log(e)
+        }
+
+        if (e.response) {
+            if(e.response.status) {
+                const { message } = new ErrorMessages('invite', e.response.status)
+                console.log(`Ops! Não foi possivel executar ação de aceite do convite\n ${message}`)
+            } else {
+                console.log(
+                    `Ops! Houve um problema no convite\n ${e.response.data}`
+                )
+            }
+        } else {
+            console.log(`Ops! Erro enviando convite\n ${e.message}`)
+        }
+
+        await trackingService.sendError(e)
+        process.exit(1)
+    }
+}

package/src/cmd/list.js

@@ -0,0 +1,36 @@
+const inquirer = require('inquirer')
+const TargetService = require('../service/TargetService')
+const {workspace} = require('../service/Workspace')
+const targetService = new TargetService(workspace)
+
+module.exports = async function list(args) {
+    try {
+        const targets = await targetService.getTargets()
+        if(targets.length === 0) {
+            console.error('Houve um erro ao listar os targets.')
+            return process.exit(0)
+        }
+        const res = await inquirer.prompt([
+            {
+                name: 'selected',
+                type: 'rawlist',
+                message: 'Selecione o Target em que deseja ver os templates:',
+                choices: targets
+            }
+        ])
+    
+        const selectedTarget = targets.find(tg => tg.name === res.selected)
+        
+        if(args.template){
+            const boilerplates = selectedTarget.miniAppBoilerplateList
+            if(!boilerplates) {
+                console.error(`O Target ${selectedTarget.name} não possui boilerplates disponíveis.`)
+                return process.exit(0)
+            }
+            boilerplates.map( boilerplate => console.log(`${boilerplate.name}: ${boilerplate.description} \n`))
+        }
+    } catch (error) {
+        console.error('Houve um erro ao listar os targets.')
+        return process.exit(0)
+    }
+}

package/src/cmd/login.js

@@ -0,0 +1,51 @@
+const inquirer = require('inquirer')
+const config = require('config')
+const open = require('open')
+const TrackingEitriAnalytics = require('../service/TrackingEitriAnalytics')
+const Server = require('../service/Server')
+
+module.exports = async function login(args) {
+    try {
+        console.log("==========================================\n\n")
+
+        const {openPortalAnwser} = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'openPortalAnwser',
+                message: ' Podemos guiá-lo até o nosso sagrado portal?',
+            },
+        ])
+
+        const urlAdminManagerCredential = `${config.get("managerFront").url}${config.get("managerFront").cliGenerateLoginCredential}`
+        const res = Server.startCliLogin()
+        const urlAdminManagerCredentialWithParams = `${urlAdminManagerCredential}?cli_login=true&redirect_url=http://${res?.host}:${res?.port}/cli-login`
+        let portalOpenMessage = ""
+
+
+        if (openPortalAnwser) {
+            console.log("\n", "Abrindo o portal...")
+            try {
+                open(urlAdminManagerCredentialWithParams)
+                portalOpenMessage = "Portal aberto em seu navegador padrão"
+            } catch (error) {
+                portalOpenMessage = "Não foi possível abrir o portal. Você terá que fazer isso dessa vez. Copie o link e cole em seu navegador para fazer o login na Eitri CLI. " + urlAdminManagerCredentialWithParams
+            }
+        } else {
+            portalOpenMessage = "Copie o link e cole em seu navegador para fazer o login na Eitri CLI. " + urlAdminManagerCredentialWithParams
+        }
+
+        console.log("\n", portalOpenMessage)
+        console.log("\n\n Aguardando pela autenticação...")
+    } catch (error) {
+        await TrackingEitriAnalytics.sendEvent({
+            command: "login",
+            success: false,
+            errorMessage: error?.message
+        })
+
+        console.log('Erro inesperado, tente novamente mais tarde.', error?.message)
+
+        process.exit(1)
+    }
+
+}

package/src/cmd/manage-env.js

@@ -0,0 +1,129 @@
+const path = require('path')
+const config = require('config')
+
+const { workspace } = require('../service/Workspace')
+const MiniLog = require('../service/MiniLog')
+const {
+    buildEnvFile,
+    environmentVariable,
+    panicCheckEnvList,
+    sendEnvfile,
+    getEnvName,
+} = require('../util/manage-env')
+
+const ManageEnvService = require('../service/ManageEnvService')
+const manageEnvService = new ManageEnvService()
+
+const blindGuardian = workspace.blindGuardian
+const CONFIG_WORKSPACE = config.get('workspace')
+
+module.exports = async function manageEnv(envList, cmd) {
+    try {
+        if (cmd.read) getEnv(cmd)
+        else setEnv(envList, cmd)
+    } catch (e) {
+        console.log(e.message)
+        if (cmd.verbose) {
+            console.log(e)
+        }
+        process.exit(1)
+    }
+}
+
+const getEnv = async (cmd) => {
+    const miniLog = new MiniLog(config.get('miniLog'))
+    const folder2watch = path.join(process.cwd(), 'src')
+
+    workspace.setFolder2Watch(folder2watch)
+    blindGuardian.readConf()
+
+    workspace.setServerUrl(CONFIG_WORKSPACE.url)
+    await workspace.init()
+    await miniLog.connect(workspace.userEmail)
+    const miniConf = workspace.getMiniConf()
+    const envName = getEnvName(cmd)
+    const fileNames = await workspace.getFileNames('server')
+
+    try {
+        const envVariables = await manageEnvService.getEnvVariables(
+            workspace,
+            CONFIG_WORKSPACE.colossus.url,
+            miniConf,
+            envName,
+            workspace.userEmail,
+            fileNames[0]
+        )
+        delete envVariables.greeting
+        delete envVariables.warning
+
+        console.log(JSON.stringify(envVariables, null, 4))
+    } catch (error) {
+        if (cmd.verbose) {
+            console.log(error)
+        } else {
+            console.log(error.message)
+        }
+    } finally {
+        process.exit(0)
+    }
+}
+
+const setEnv = async (envList, cmd) => {
+    try {
+        panicCheckEnvList(envList)
+        const environmentVariables = environmentVariable(envList)
+        const miniLog = new MiniLog(config.get('miniLog'))
+        const folder2watch = path.join(process.cwd(), 'src')
+
+        workspace.setFolder2Watch(folder2watch)
+        blindGuardian.readConf()
+
+        workspace.setServerUrl(CONFIG_WORKSPACE.url)
+        await workspace.init()
+        await miniLog.connect(workspace.userEmail)
+        let miniConf = workspace.getMiniConf()
+        const fileNames = await workspace.getFileNames('server')
+        let envName = getEnvName(cmd)
+        let envFile = buildEnvFile(
+            envName,
+            fileNames,
+            environmentVariables,
+            miniConf.slug,
+            miniConf.version
+        )
+
+        if (cmd.verbose) {
+            console.log(
+                `Enviando env ${
+                    CONFIG_WORKSPACE.colossus.url
+                }\n${JSON.stringify(envFile, null, 4)}`
+            )
+        }
+
+        const result = await sendEnvfile(
+            workspace,
+            `${CONFIG_WORKSPACE.colossus.url}`,
+            envFile
+        )
+        if (result.statusText.toLowerCase() === 'ok') {
+            console.log('As variaveis de ambiente foram criadas com sucesso.')
+        }
+    } catch (error) {
+        if (cmd.verbose) {
+            console.error('manageEnv.setEnv.fail', error)
+        } else {
+            if (error.isAxiosError) {
+                if (error.response) {
+                    const data = error.response.data || { error: error.message }
+                    console.error('manageEnv.setEnv.apiError', data.error)
+                } else {
+                    console.error('manageEnv.setEnv.connectionError', error.message)
+                }
+            } else {
+                console.error('manageEnv.setEnv.internalError', error)
+            }
+        }
+    } finally {
+        process.exit(0)
+    }
+}

package/src/cmd/open-share.js

@@ -0,0 +1,6 @@
+const start = require('./start')
+
+module.exports = async function openShare(shareId, cmdObj) {
+    let args = {...cmdObj, shareId: shareId}
+    await start(args)
+}