eitri-cli 1.0.2

package/src/cmd/order-details.js

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

package/src/cmd/push-version.js

@@ -0,0 +1,182 @@
+const path = require('path')
+const { workspace } = require('../service/Workspace')
+const validator = require('./validate')
+const MiniLog = require('../service/MiniLog')
+const TrackingService = require('../service/TrackingService')
+const fs = require('fs')
+const config = require('../service/ConfigService')
+const TargetService = require('../service/TargetService')
+const inquirer = require('inquirer')
+const TrackingEitriAnalytics = require('../service/TrackingEitriAnalytics')
+
+const blindGuardian = workspace.blindGuardian
+const trackingService = new TrackingService(blindGuardian)
+const targetService = new TargetService(workspace)
+
+module.exports = async function pushVersion(cmdObj) {
+    try {
+        await validator.assertPushVersionMessage(cmdObj.message)
+        await validator.assertCommandNotRunning('push-version')
+        const folder2watch = path.join(process.cwd(), 'src')
+        const miniLog = new MiniLog(config.get('miniLog'))
+        workspace.setFolder2Watch(folder2watch)
+
+        const resourceFolders2watch = [path.join(process.cwd(), 'public')]
+        if (fs.existsSync(resourceFolders2watch)) {
+            workspace.setResourceFolder2Watch(resourceFolders2watch)
+        }
+        workspace.publishing = true
+        let miniConf = workspace.getMiniConf()
+        let validateResult = checkErros(miniConf)
+
+        if (!validateResult.isSuccess()) {
+            console.log(
+                'Por favor, verifique atentamente os erros exibidos acima. Siga o exemplo abaixo: ' +
+                `
+module.exports = {
+
+  // Dados da sua empresa
+  organization: {
+    "name": "Minha Empresa"
+  },
+
+  // Nome do seu mini app
+  "name": "Meu Mini App",
+
+  // Titulo do mini app, que vai em baixo do botao na pagina de transacoes
+  "title": "Meu super mini app",
+
+  // Chave para gerar a ordem/qrcode de pagamento (opcional)
+  "public-key": "",
+
+  // Identificador amigavel para colocar em uma url
+  "slug": "com.eitri.loja",
+
+  // Versao do mini app
+  "version": "1.0.0",
+
+${await targetService.getAppConfExampleSnippet()}
+};
+
+
+        `
+            )
+
+            return
+        }
+        const separator = '======================================================================='
+        blindGuardian.readConf()
+        workspace.setServerUrl(config.get('workspace').url)
+        console.log('Conectando à forja de Eitri')
+        await workspace.init()
+        await miniLog.connect(workspace.userEmail)
+        console.log(separator)
+        console.log('Analisando versões')
+        const {target} = await workspace.checkVersions()
+
+        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()
+        const webhooks = workspace.getWebhooks()
+        printAvailableWebhooks(webhooks)
+        console.log('')
+        console.log(separator)
+        console.log('Gerando eitri-app')
+
+        const start = Date.now()
+        let pushVersionPromise = miniLog.awaitForPushVersion()
+        await workspace.pushVersionAsJson(cmdObj.message)
+        await pushVersionPromise
+        console.log(separator)
+        console.log('\x1b[1m\x1b[32mSucesso!!\x1b[0m');
+        console.log(`\x1b[1mA versão [${miniConf.version}] do seu eitri-app foi gerada e está\x1b[0m`);
+        console.log('\x1b[1mdisponível no Eitri-console para aprovação\x1b[0m');
+        console.log(separator)
+
+
+        await track(miniConf, start)
+        await TrackingEitriAnalytics.sendEvent({
+            command: "push-version",
+            success: true,
+            data: {
+                eitriApp: {
+                    ...miniConf,
+                    organization: Object.keys(miniConf?.organization).length !== 0 ? miniConf?.organization : "-"
+                },
+                target,
+                startDate: `${start}`,
+            }
+        })
+        process.exit(0)
+    } catch (e) {
+        if (cmdObj.verbose) {
+            console.error(e)
+        } else if (e.response && e.response.data && e.response.data.friendlyMessage) {
+            console.log(`\x1b[1m\x1b[31m${e.response.data.friendlyMessage}\x1b[0m`);
+        } else if (e && e.message) {
+            console.log(`\x1b[1m\x1b[31m${e.message}\x1b[0m`);
+        } else {
+            console.log(`\x1b[1m\x1b[31mNão será possível continuar por enquanto. A forja encontrou um erro.\x1b[0m`);
+        }
+
+        await trackingService.sendError(e)
+        await TrackingEitriAnalytics.sendEvent({
+            command: "push-version",
+            success: false,
+            errorMessage: e?.message
+        })
+        process.exit(1)
+    }
+}
+
+function printAvailableWebhooks(webhooks) {
+    if(!webhooks || webhooks.length === 0) return
+    console.log('\nWebhooks do MiniApp.')
+    console.table(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)
+}
+
+function checkErros(miniConf) {
+    let validateResult = validator.validate(miniConf)
+    validateResult.errors.forEach(message => console.log(message))
+    return validateResult
+}
+
+async function logPermissionsAndOpenPrompt(addedPermissions, removedPermissions, cmdObj) {
+    const GREEN_COLOR = '\x1b[32m'
+    const RED_COLOR = '\x1b[31m'
+    const MINIMAL_LENGTH = 0
+    if(addedPermissions.length > MINIMAL_LENGTH) {
+        console.log(`${GREEN_COLOR}\nPermissões adicionadas: ${addedPermissions}${GREEN_COLOR}`)
+    }
+    if(removedPermissions.length > MINIMAL_LENGTH) {
+        console.log(`${RED_COLOR}Permissões removidas: ${removedPermissions}\n${RED_COLOR}`)
+    }
+    if(!cmdObj.yes && (addedPermissions.length > MINIMAL_LENGTH || removedPermissions.length > MINIMAL_LENGTH)) {
+        const answer = await inquirer.prompt([
+            {
+                name: 'option',
+                message: 'Houve uma alteração nas permissões em relação a versão publicada. Deseja Continuar?',
+                type: 'rawlist',
+                choices: ['Sim', 'Não']
+            }
+        ])
+        if(answer.option === 'Não') {
+            process.exit(0)
+        }
+    }
+}

package/src/cmd/show-message-if-outdated-package.js

@@ -0,0 +1,32 @@
+const {getVersion} = require('../cmd/version')
+module.exports = function showMessageIfOutdatedPackage(workspace, packageName ) {
+
+    let miniConf = workspace.getMiniConf()
+    const userVersion = miniConf[packageName]
+    const publishedVersion = getVersion(packageName)
+
+    if('eitri-app-components' === packageName) {
+        if(/^1/.test(`${userVersion}`)){
+            console.log('\n')
+            console.log('\t╔═══════════════════════════════════════╗')
+            console.log('\t║ Atenção: O suporte para as bibliotecas║')
+            console.log('\t║ de componente com versão anteriores a ║')
+            console.log('\t║ 2.0.0 finalizarão em outubro de 2021. ║')
+            console.log('\t╚═══════════════════════════════════════╝\n')
+        } else {
+            if (userVersion !== publishedVersion) {
+                console.log(
+                    `\t> Alerta: Já existe uma versão ${ publishedVersion} da biblioteca ${packageName}.\n\t> Você está usando uma mais antiga (${userVersion}), recomenda-se atualizar.`
+                )
+                console.log('\t> Maiores informações em: https://eitri-app-components.calindra.com.br/\n')
+            }
+        }
+    } else {
+        if (userVersion !== publishedVersion) {
+            console.log(
+                `\t> Alerta: Já existe uma versão ${ publishedVersion} da biblioteca ${packageName}.\n\t> Você está usando uma mais antiga (${userVersion}), recomenda-se atualizar.`
+            )
+            console.log('\t> Maiores informações em: https://super-app-client.calindra.com.br/docs/eitri-app-client/\n')
+        }
+    }
+}

package/src/cmd/signup.js

@@ -0,0 +1,69 @@
+const BlindGuardian = require('../service/BlindGuardian')
+const validator = require('./validate')
+const User = require('../model/User')
+const UserLocalCredential = require('../util/UserLocalCredential')
+const TrackingEitriAnalytics = require('../service/TrackingEitriAnalytics')
+
+module.exports = async function signup(args) {
+    try {
+
+        process.env['LOG_LEVEL'] = args.verbose
+
+        if (!args.force) {
+            await validator.assertCommandNotRunning('signup')
+        }
+
+        const { name, email } = args
+
+        if(!name) {
+            console.log('"Nome" deve ser fornecido!')
+            process.exit(1)
+        }
+
+        if(!email) {
+            console.log('"E-mail" deve ser fornecido!')
+            process.exit(1)
+        }
+        const user = new User(name, email)
+
+        const blind = new BlindGuardian()
+        const persistentUser = await blind.createUser(user)
+        const {credential } = persistentUser
+        const { clientId: devUser, clientSecret: devKey } = credential
+        const conf = { devUser, devKey }
+
+        new UserLocalCredential().saveContent(conf)
+
+        TrackingEitriAnalytics.sendEvent({
+            command: "signup",
+            success: true,
+            data: {
+                args
+            }
+        })
+    } catch (e) {
+        await TrackingEitriAnalytics.sendEvent({
+            command: "signup",
+            success: false,
+            errorMessage: e?.message
+        })
+
+        if (args.verbose) console.error(e)
+
+        if (e.response && e.response.data && e.response.data.friendlyMessage) {
+            const { name, friendlyMessage } = e.response.data
+
+            console.error(`ERRO: ${friendlyMessage}`)
+
+            if (name === 'NameCharacterLimitExceed') {
+                process.exit(1)
+            }
+        } else if (e && e.message) {
+            console.error(`ERRO: ${e.message}`)
+        } else {
+            console.log('Erro inesperado, tente novamente mais tarde.')
+        }
+
+        process.exit(1)
+    }
+}

package/src/cmd/start.js

@@ -0,0 +1,171 @@
+const path = require('path')
+const Watcher = require('../service/Watcher')
+const { workspace } = require('../service/Workspace')
+const MiniLog = require('../service/MiniLog')
+const { version } = require('./version')
+const showMessageIfOutdatedPackage = require('./show-message-if-outdated-package.js')
+const validator = require('./validate')
+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 blindGuardian = workspace.blindGuardian
+const hashFolder = workspace.hashFolder
+const trackingService = new TrackingService(blindGuardian, { ignoreCredentialError: true })
+const watcher = new Watcher(workspace, hashFolder, trackingService)
+
+module.exports = async function start(args) {
+    try {
+        if (!args.force) {
+            await validator.assertCommandNotRunning('start')
+        }
+
+        const miniLog = new MiniLog(config.get('miniLog'))
+
+        // TODO EITRI: descomentar apos publicacao das libs no npm
+        //version()
+
+        const resourceFolders2watch = [path.join(process.cwd(), 'public')]
+        if (fs.existsSync(resourceFolders2watch)) {
+            workspace.setResourceFolder2Watch(resourceFolders2watch)
+        }
+        
+        const url = config.get('workspace').url
+        const setupResult = await workspace.setup()
+        const target = setupResult.target.name
+        
+        let targetConfig = {}
+
+        if(args.listTargetConfigs) {
+            await listTargetConfigs(target)
+            process.exit(1)
+        }
+
+        if(args.targetConfig) {
+            targetConfig = await askTargetConfig(args, target)
+        } else {
+            targetConfig = await getDefaultTargetConfig(target)
+        }
+
+        blindGuardian.readConf()
+        const qrCodeUrl = config.get('qrCode').url
+        if (args.verbose) {
+            blindGuardian.verbose = true
+            miniLog.verbose = true
+            console.log('WS url', url)
+        }
+        workspace.setServerUrl(url)
+        workspace.setQrCodeUrl(qrCodeUrl)
+        await workspace.init()
+        const silentOnConnect = args.verbose ? false : true
+        await miniLog.connect(workspace.userEmail, silentOnConnect)
+
+        // TODO EITRI: descomentar apos publicacao das libs no npm
+        // setupResult.state.libs.forEach(lib => {
+        //     showMessageIfOutdatedPackage(workspace, lib.name)
+        // })
+
+        if (args.unzip) {
+            await workspace.uploadAll(args)
+        } else {
+            await workspace.uploadZip(args)
+        }
+        const loadedTarget = await workspace.getTarget()
+        const platform = loadedTarget.platform
+        await handleStartServer(args, trackingService, watcher, workspace, target, targetConfig, platform)
+
+        TrackingEitriAnalytics.sendEvent({
+            command: "start",
+            success: true,
+            data: {
+                args,
+                platform,
+                workspace: {
+                    id: workspace?.target?.id,
+                    name: workspace?.target?.name,
+                    superAppClientLibName: workspace?.target?.superAppClientLibName,
+                    componentsLibName: workspace?.target?.componentsLibName,
+                    description: workspace?.target?.description,
+                    status: workspace?.target?.status,
+                    platform: workspace?.target?.platform,
+                    organization: {...workspace?.target?.organization},
+                    userEmail: workspace?.userEmail,
+                },
+                eitriApp: {
+                    name: workspace?._miniConf?.name,
+                    title: workspace?._miniConf?.title,
+                    slug: workspace?._miniConf?.slug,
+                    version: workspace?._miniConf?.version,
+                    organization: workspace?._miniConf?.organization,
+                    "eitri-app-components": workspace?._miniConf?.["eitri-app-components"],
+                    "eitri-app-client": workspace?._miniConf?.["eitri-app-client"],
+                    "eitri-commons": workspace?._miniConf?.["eitri-commons"],
+                    publickey: workspace?._miniConf?.["public-key"]
+                }
+            }
+        })
+    } catch (e) {
+        TrackingEitriAnalytics.sendEvent({
+            command: "start",
+            success: false,
+            data: {
+                args,
+            },
+            errorMessage: e?.message || ""
+        })
+
+        if (args.verbose) console.error(e)
+
+        if (e.response && e.response.data && e.response.data.friendlyMessage) {
+            const { name, friendlyMessage } = e.response.data
+
+            console.error(`ERRO: ${friendlyMessage}`)
+
+            if (name === 'NameCharacterLimitExceed') {
+                process.exit(1)
+            }
+        } else if (e && e.message) {
+            console.log(`\x1b[1m\x1b[31m${e.message}\x1b[0m`);
+        } else {
+            console.log(`\x1b[1m\x1b[31mEitri encontrou um erro e por isso parou, tente novamente mais tarde.\x1b[0m`);
+        }
+
+        await trackingService.sendError(e)
+
+        process.exit(1)
+    }
+}
+
+async function askTargetConfig(args, target) {
+    const avaiableConfigs = await workspace.getTargetConfig(args.targetConfig, target)
+
+    console.log(`Utilizando configuração: ${avaiableConfigs[0].id}`)
+    return avaiableConfigs[0]
+   
+}
+
+async function getDefaultTargetConfig(target) {
+    const configs = await workspace.getTargetConfig('default', target)
+    return configs[0]
+}
+
+async function listTargetConfigs(target) {
+    const avaiableConfigs = await workspace.getAllTargetConfigs(target)
+
+    const avaiableConfigsIds = avaiableConfigs.map(config => config.id)
+
+    const res = await inquirer.prompt([
+        {
+            name: 'accepted',
+            type: 'rawlist',
+            message: 'Configurações disponíveis:',
+            choices: avaiableConfigsIds
+        }
+    ]).then(input => input)
+
+    const config = avaiableConfigs.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/cmd/tail-logs.js

@@ -0,0 +1,26 @@
+const path = require('path')
+const {Workspace} = require('../service/Workspace')
+const BlindGuardian = require('../service/BlindGuardian')
+const MiniLog = require('../service/MiniLog')
+const version = require('./version')
+const HashFolder = require('../service/HashFolder')
+const blindGuardian = new BlindGuardian()
+const hashFolder = new HashFolder()
+const workspace = new Workspace(blindGuardian, hashFolder)
+
+module.exports = async function tailLogs(clientEmail) {
+    const config = require('config')
+    const miniLog = new MiniLog(config.get('miniLog'))
+    version()
+    const folder2watch = path.join(process.cwd(), 'src')
+    workspace.setFolder2Watch(folder2watch)
+    blindGuardian.readConf()
+
+    const url = config.get('workspace').url
+    workspace.setServerUrl(url)
+    await workspace.init()
+    await miniLog.connect(workspace.userEmail)
+    let miniConf = await workspace.getMiniConf()
+    let fullUrl = `https://miniapps.eitri.com/open/${miniConf.slug}?logsFrom=${clientEmail}&logsTo=${workspace.userEmail}`
+    console.log(fullUrl)
+}

package/src/cmd/test-initialization-params.js

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

package/src/cmd/validate.js

@@ -0,0 +1,170 @@
+const ValidateResult = require('../service/ValidateResult')
+const ps = require('ps-node')
+
+const NAME_TITLE_REGEX = /^([a-zA-ZÀ-ú0-9\s]|-|\+|&|!)+$/
+const SLUG_REGEX = /^(\.|[a-z0-9]|-)+$/i
+
+module.exports.NAME_TITLE_REGEX = NAME_TITLE_REGEX
+module.exports.SLUG_REGEX = SLUG_REGEX
+
+module.exports.assertCommandNotRunning = function (commandName) {
+    return new Promise((resolve, reject) => {
+        ps.lookup({command: 'node'}, (err, processes) => {
+            if (err) throw new Error('erro ao executar comando')
+
+            console.log('\x1b[1m\x1b[34mIniciando eitri builder\x1b[0m');
+
+            const runningProcesses = processes.filter((process) => {
+                let isAmeToolsRunning = false
+                let isCommandRunning = false
+
+                for (var argument of process.arguments) {
+                    if (argument.includes('eitri')) {
+                        isAmeToolsRunning = true
+                        continue
+                    }
+                    if (argument === commandName) isCommandRunning = true
+                }
+
+                return isAmeToolsRunning && isCommandRunning
+            })
+
+            // if (runningProcesses && runningProcesses.length > 1) {
+            //     console.error('EITRI: o comando ' + commandName + ' já está sendo executado')
+            //     reject()
+            //     process.exit(1)
+            // } else {
+                resolve()
+            // }
+        })
+    })
+}
+
+//TODO: ESSE MÓDULO DEVE SER APAGADO, QUANDO NÃO EXISTIR MAIS O COMANDO PUBLISH
+module.exports.assertPublishMessage = function (publishMessage) {
+    if (publishMessage) {
+        if (publishMessage.length > 255) {
+            console.error(`Se fornecida, a mensagem de publicação precisa ter menos de 255 caracteres. Tamanho atual: ${publishMessage.length}`)
+            process.exit(1)
+        }
+    }
+}
+
+module.exports.assertBuildMessage = function (buildMessage) {
+    if (buildMessage) {
+        if (buildMessage.length > 255) {
+            console.error(`Se fornecida, a mensagem de build precisa ter menos de 255 caracteres. Tamanho atual: ${buildMessage.length}`)
+            process.exit(1)
+        }
+    }
+}
+
+module.exports.assertPushVersionMessage = function (buildMessage) {
+    if (buildMessage) {
+        if (buildMessage.length > 255) {
+            console.error(`Se fornecida, a mensagem de push-version precisa ter menos de 255 caracteres. Tamanho atual: ${buildMessage.length}`)
+            process.exit(1)
+        }
+    }
+}
+
+module.exports.validate = function (miniConf) {
+    let validateResult = new ValidateResult([])
+    let isversionvalid = checkAmeVersion(miniConf)
+
+
+    if (!miniConf.organization) {
+        validateResult.addError(
+            'Por Favor, preencha o campo \'organization\' (Utilize apenas caracteres maiusculo, minusculo e espaco. Ex: \'Minha Empresa\').'
+        )
+    }
+
+    if (!miniConf.name) {
+        validateResult.addError(
+            'Por Favor, preencha o campo \'name\' (Utilize apenas caracteres maiusculo, minusculo e espaco. Ex: \'Meu Mini App\').'
+        )
+    } else if (!miniConf.name.match(NAME_TITLE_REGEX)) {
+        validateResult.addError(
+            'Por Favor, preencha o campo \'name\' corretamente antes de publicar'
+        )
+    }
+
+    if (!miniConf.title) {
+        validateResult.addError(
+            'Por Favor, preencha o campo \'title\' (Utilize apenas caracteres maiusculo, minusculo e espaco. Ex: \'Meu super mini app\').'
+        )
+    } else if (!miniConf.title.match(NAME_TITLE_REGEX)) {
+        validateResult.addError(
+            'Por Favor, preencha o campo \'title\' corretamente antes de publicar'
+        )
+    }
+
+    if (!miniConf.slug) {
+        validateResult.addError(
+            'Por Favor, preencha o campo \'slug\' (Utilize apenas caracteres minusculo e ponto. Ex: \'com.eitri.loja\').'
+        )
+    } else if (!miniConf.slug.match(SLUG_REGEX)) {
+        validateResult.addError(
+            'Por Favor, preencha o campo \'slug\' corretamente antes de publicar'
+        )
+    }
+
+    if (!isversionvalid) {
+        validateResult.addError(
+            'Por Favor, preencha o campo \'version\' (Utilize esse formato X.Y.Z. Ex: \'1.0.0\').'
+        )
+    }
+
+    // Se houver objeto privacy, onboarding eh obrigatorio. Mode eh opcional.
+    if (miniConf.privacy) {
+        if (miniConf.privacy.onBoarding) {
+            const onBoarding = miniConf.privacy.onBoarding
+            const onBoardingItems = onBoarding.items
+            if (!Array.isArray(onBoardingItems)) {
+                validateResult.addError(
+                    'Objeto de configuração "privacy.onBoarding.items" deve ser um array de {img, title, description}'
+                )
+            } else {
+                onBoardingItems.forEach((item, index) => {
+                    if (!(item.img && item.title && item.description)) {
+                        validateResult.addError(
+                            `Um ou mais itens do objeto de "onBoarding" nao possui as propriedades {img, title, description}: ${JSON.stringify(item)}`
+                        )
+                    }
+
+                    try {
+                        new URL(item.img)
+                    } catch (e) {
+                        if (e.code === 'ERR_INVALID_URL') {
+                            validateResult.addError(
+                                `onBoarding.Item[${index}] invalido. Atributo "img" nao eh uma URL: ${item.img}`
+                            )
+                        }
+                    }
+                })
+            }
+        } else {
+            validateResult.addError(
+                'Objeto "privacy" nao possui atributo "onBoarding"'
+            )
+        }
+    }
+    return validateResult
+}
+
+function checkAmeVersion(miniConf) {
+    if (!miniConf.version) {
+        return false
+    }
+    let value = typeof miniConf.version
+    if (!(value === 'string')) {
+        return false
+    }
+
+    const digit = miniConf.version.match(/^(\d+\.)(\d+\.)(\d+)$/)
+    if (!digit) {
+        return false
+    }
+
+    return true
+}