eitri-cli 1.0.2

package/src/service/WorkspaceManager.js

@@ -0,0 +1,74 @@
+const io = require('socket.io-client')
+const fs = require('fs')
+const openDocs = require('../util/open-docs')
+const QRCodeFactory = require('../service/QRCodeFactory')
+const TrackingService = require('../service/TrackingService')
+const config = require('config')
+const Server = require('../service/Server')
+const qrcodeTerminal = require('qrcode-terminal')
+const TERMINAL_PRINTER_NAME = 'terminal'
+
+class WorkspaceManager {
+
+    constructor(blindGuardian) {
+        this.blindGuardian = blindGuardian
+        this.baseUrl = config.get('workspaceManager').url
+        this.contextPath = config.get('workspaceManager').contextPath
+        this.ioPath = config.get('workspaceManager').path
+        this.verbose = false
+    }
+
+    qrConfig(configPath, args) {
+        const cliSocket = io.connect(this.baseUrl, { path: this.ioPath })
+        if (this.verbose) console.log(`Conectando ao ${this.baseUrl} path = ${this.ioPath} ...`)
+        cliSocket.on('connect', () => {
+            if (this.verbose) console.log(`Conectado ao ${this.baseUrl} path = ${this.ioPath} .`)
+            cliSocket.emit('getCliToken')
+        })
+        cliSocket.on('openDocs', () => {
+            openDocs()
+        })
+        cliSocket.on('token', async (token) => {
+            const fullUrl = `https://miniapps.amedigital.com/open/wm2?token=${token}`
+
+            if(args && args.verbose) {
+                console.log('QR Code URL', fullUrl)
+            }
+
+            if(process.env.AAT_QRCODE_PRINTER === TERMINAL_PRINTER_NAME || args && args.qrPrinter === TERMINAL_PRINTER_NAME) {
+                qrcodeTerminal.generate(fullUrl, { small: true } )
+            } else {
+                const qrCodePath = await new QRCodeFactory().create(fullUrl)
+                const sanitizedQrCodePath = qrCodePath.replace('/~', '')
+                if(args) {
+                    Server.startServer({ qrCodePath: sanitizedQrCodePath, qrPrinter: args.qrPrinter })
+                } else {
+                    Server.startServer({ qrCodePath: sanitizedQrCodePath })
+                }
+            }
+        })
+        cliSocket.on('error', (error) => {
+            if (this.verbose) console.log(error)
+        })
+        cliSocket.on('setCliConf', (conf, fn) => {
+            const confContent = `module.exports = ${JSON.stringify(conf, null, 4)}`
+            fs.writeFile(configPath, confContent, (err) => {
+                if (err) {
+                    console.log('Erro ao salvar a config.')
+                    fn('error')
+                } else {
+                    console.log(`Credenciais salvas em ${configPath}.\nAperte control+c para finalizar.`)
+                    this.track()
+                    fn('success')
+                }
+            })
+        })
+    }
+
+    track() {
+        let trackingService = new TrackingService(this.blindGuardian)
+        trackingService.sendSignup()
+    }
+}
+
+module.exports = WorkspaceManager

package/src/service/factories/DoubtsStarterFactory.js

@@ -0,0 +1,25 @@
+const open = require('open')
+const config = require('config')
+const DEFAULT_DOC_CREATE_URL = 'https://eitri.calindra.com.br/#/?id=create'
+
+function DoubtsStarter(args, trackingService, watcher, workspace ) {
+    this.args = args
+    this.trackingService = trackingService
+    this.watcher = watcher
+    this.workspace = workspace
+
+    this.startServer = async function () {
+        await open((config.doc && config.doc.createUrl) || DEFAULT_DOC_CREATE_URL)
+    }
+}
+
+function DoubtsStarterFactory() {
+    this.create = function (args, trackingService, watcher, workspace) {
+        return new DoubtsStarter(args, trackingService, watcher, workspace)
+    }
+}
+
+module.exports = DoubtsStarterFactory
+
+
+

package/src/service/factories/MiniWebAppFactory.js

@@ -0,0 +1,43 @@
+const fs = require('fs')
+const path = require('path')
+const WookCoffee = require('./WoodCoffeeFactory')
+const {getVersion} = require('../../cmd/version')
+
+class MiniWebAppFactory extends WookCoffee {
+
+    async create(projectName, templateUrl) {
+
+        if(!templateUrl) {
+            throw new Error(`Forneça um template para criar seu Mini App. ${templateUrl} não é um template válido. Duvidas? Execute 'eitri create --help'`)
+        }
+
+        const projectPath = await this.verifyFolder(projectName)
+
+        await this.createTempFile()
+        
+        await this.template(projectName, templateUrl, projectPath)
+
+        return { projectPath }
+    }
+
+    writeAmeConf(project, conf, libsName) {
+        return new Promise((resolve, reject) => {
+
+            libsName.forEach(libName => {
+                conf[libName] = getVersion(libName)
+            })
+
+            conf['version'] = '0.1.0'
+
+            let confString = `module.exports = ${JSON.stringify(conf, null, 4)}`
+            fs.writeFile(path.join(project.projectPath, 'miniapp.conf.js'), confString, (err) => {
+                if (err) {
+                    return reject(err)
+                }
+                resolve()
+            })
+        })
+    }
+}
+
+module.exports = MiniWebAppFactory

package/src/service/factories/QRCodeStarterFactory.js

@@ -0,0 +1,78 @@
+const QRCodeFactory = require('../QRCodeFactory')
+const TrackService = require('../TrackService')
+const Server  = require('../Server')
+const qrcodeTerminal = require('qrcode-terminal')
+const TERMINAL_PRINTER_NAME = 'terminal'
+
+function QRCodeStarter(args, trackingService, watcher, workspace, targetConfig ) {
+    this.args = args
+    this.trackingService = trackingService
+    this.watcher = watcher
+    this.workspace = workspace
+    this.targetConfig = targetConfig
+
+    this.startServer = async function () {
+        let fullUrl
+        if (this.args.oldQrcode) {
+            fullUrl = await this.workspace.getWorkspaceURL(this.args, this.targetConfig)
+        } else {
+            const {miniAppUrl} = await this.workspace.getNewWorkspaceURL(this.args, this.targetConfig)
+            fullUrl =  miniAppUrl
+        }
+
+        if (this.args.verbose) {
+            console.log(`QrCodeUrl: ${fullUrl}`)
+        }
+        const qrCodePath = await new QRCodeFactory().create(fullUrl)
+
+        if (this.args.verbose) {
+            console.log(`QrCode Path: ${qrCodePath}`)
+        }
+
+        if(process.env.AAT_QRCODE_PRINTER === TERMINAL_PRINTER_NAME || this.args.qrPrinter === TERMINAL_PRINTER_NAME) {
+            qrcodeTerminal.generate(fullUrl, {small: true})
+        }
+
+        const libsInfoForGA = this.args.libsInfoForGA
+
+        this.watcher.start()
+        let miniConf = this.workspace.getMiniConf()
+        TrackService.track(miniConf, this.trackingService, libsInfoForGA)
+        // tryToOpenAndroidEmulator(fullUrl, this.args)
+        if(this.args.showDeeplink){
+            console.log('######################################')
+            console.log('########### Deep Link URL ############')
+            console.log('######################################')
+            console.log(`${fullUrl}`)
+            console.log('######################################')
+        }
+        Server.startServer({ ...this.args, qrCodePath})
+    }
+}
+
+function tryToOpenAndroidEmulator(fullUrl, args) {
+    try {
+        const cmd = `adb shell am start -a android.intent.action.VIEW -d "${encodeURIComponent(fullUrl)}"`
+        let options = {}
+        if (args.verbose) {
+            options.stdio = 'inherit'
+            require('child_process').execSync(cmd, options)
+        } else {
+            require('child_process').exec(cmd, options, () => {
+                // ignora erros
+            })
+        }
+    } catch(e) {
+        if (args.verbose) {
+            console.log(e)
+        }
+    }
+}
+
+function QRCodeContentFactory(){
+    this.create = function (args, trackingService, watcher, workspace, targetConfig) {
+        return new QRCodeStarter(args, trackingService, watcher, workspace, targetConfig )
+    }
+}
+
+module.exports = QRCodeContentFactory

package/src/service/factories/WebStarterFactory.js

@@ -0,0 +1,88 @@
+const base64url = require('base64url')
+const Server  = require('../Server')
+const TrackService = require('../TrackService')
+const Payload = require('../../model/Payload')
+
+function WebAppStarter(args, trackingService, watcher, workspace, targetConfig ) {
+    this.args = args
+    this.trackingService = trackingService
+    this.watcher = watcher
+    this.workspace = workspace
+    this.targetConfig = targetConfig
+
+
+    const createWebMiniappPayload = (shareId) => {
+        const shareEnviroment = process.env.NODE_ENV || 'hml'
+        const payload = new Payload(shareId, shareEnviroment)
+        return base64url.encode(JSON.stringify(payload))
+    }
+
+    /**
+     * Cria url final de abertura do target, já com todos os parâmetros necessários
+     * @param {*} runnerUrl 
+     * @param {*} slug 
+     * @param {*} qrCodeConfig 
+     * @returns 
+     */
+    const createUrlToOpenOnBrowser = (runnerUrl, slug, qrCodeConfig) => {
+        const payload = createWebMiniappPayload(qrCodeConfig.shareId)
+        return buildUrlToOpenOnStart(runnerUrl, slug, payload)
+    }
+
+    /**
+     * Monta a url que será aberta no browser com um payload já definido
+     * @param {*} runnerUrl 
+     * @param {*} miniAppSlug 
+     * @param {*} encodedMiniAppUrl 
+     * @returns 
+     */
+    const buildUrlToOpenOnStart = (runnerUrl, miniAppSlug, encodedMiniAppUrl) => {
+        return `${runnerUrl}${miniAppSlug}/${encodedMiniAppUrl}`
+    }
+    this.startServer = async function () {
+        this.watcher.start()
+
+        const miniConf = this.workspace.getMiniConf() 
+        const libsInfoForGA = this.args.libsInfoForGA
+        TrackService.track(miniConf, this.trackingService, libsInfoForGA)
+
+        const {miniAppConf} = await this.workspace.getNewWorkspaceURL(this.args, this.targetConfig)
+        const { slug } = miniConf
+
+        if(this.args.emulator){
+            Server.startServerEmulator({...this.args, bootstrapUrl: miniAppConf.miniAppBootstrapUrl, slug, http: this.workspace.getHttp() })
+            return
+        }
+
+        if(this.args.local) {
+            const runnerUrl = this.targetConfig.runnerUrl
+            const urlToOpen = createUrlToOpenOnBrowser(runnerUrl, slug, miniAppConf)
+
+            Server.startMiniAppProxyServerAndOpenTarget({
+                ...this.args,
+                http: this.workspace.getHttp(),
+                openPath: urlToOpen
+            })
+            return
+        } 
+        
+        const runnerUrl = this.targetConfig.runnerUrl
+        const urlToOpen = createUrlToOpenOnBrowser(runnerUrl, slug, miniAppConf)
+        
+        console.log('\nLink:' + '\n' + urlToOpen)
+
+        Server.startMiniAppProxyServerAndOpenTarget({
+            ...this.args,
+            http: this.workspace.getHttp(),
+            openPath: urlToOpen
+        })
+    }
+}
+
+function WebFactory() {
+    this.create = function (args, trackingService, watcher, workspace, targetConfig) {
+        return new WebAppStarter(args, trackingService, watcher, workspace, targetConfig)
+    }
+}
+
+module.exports = WebFactory

package/src/service/factories/WoodCoffeeFactory.js

@@ -0,0 +1,230 @@
+const fs = require('fs')
+const path = require('path')
+const AdmZip = require('adm-zip')
+const tmp = require('tmp')
+const util = require('util')
+const exec = util.promisify(require('child_process').exec)
+const rm = util.promisify(fs.rm)
+const { execSync } = require('child_process')
+
+class WoodCoffee {
+    static COMPONENTS_LIBRARY_VERSION_HIGHLIGHTER = '###COMPONENTS_LIBRARY_VERSION_HIGHLIGHTER###'
+    static SUPER_APP_CLIENT_VERSION_HIGHLIGHTER = '###SUPER_APP_CLIENT_VERSION_HIGHLIGHTER###'
+    static SUPER_APP_CLIENT = 'eitri-app-client'
+    static MINIAPP_COMPONENTS = 'eitri-app-components'
+
+    async create(projectName, templateUrl, target) {
+        const projectPath = await this.verifyFolder(projectName)
+        let localPath
+
+        if (process.env.LOG_LEVEL === 'full') {
+            console.log('Boilerplate localPath', localPath)
+        }
+
+
+        try {
+
+            if (templateUrl) {
+                const projectStructure = await this.template(projectName, templateUrl, projectPath, target)
+                return { projectPath, structure: projectStructure }
+            }
+        } catch (error) {
+            if (error.message.includes('Command failed')) return await this.extractZip(localPath, projectPath)
+            console.error('Erro ao obter template', error)
+        }
+        return { projectPath }
+    }
+
+    /**
+     * 
+     * @returns Objeto que representa a estrutura de diretorios do projeto criado
+     */
+    async template(projectName, templateUrl, projectPath, target) {
+        await this.downloadFromGithub(templateUrl, projectName, projectPath)
+        const aboutJsxPath = path.join(projectPath, 'src', 'views', 'About.jsx')
+
+        const miniAppConf = require(path.join(projectPath, 'miniapp.conf.js'))
+
+        if(fs.existsSync(aboutJsxPath)) {
+            try {
+
+
+                await this.checkAboutJsx(aboutJsxPath)
+                // TODO EITRI descomentar qd as libs forem pro npm
+                await this.updateAboutJSXFile(aboutJsxPath, miniAppConf)
+            } catch (e) {
+                // 'Usando template consistente para o About.jsx.'
+                const templateAboutJsxPath = path.join(path.dirname(__dirname), '..', 'util', 'AboutTemplate.jsx')
+                await this.copyFile(templateAboutJsxPath, aboutJsxPath)
+                // TODO EITRI descomentar qd as libs forem pro npm
+                await this.updateAboutJSXFile(aboutJsxPath, miniAppConf)
+            }
+        }
+        
+        return {
+            src: { views: {} },
+            miniAppConf
+        }
+    }
+
+    async checkAboutJsx(aboutJsxPath) {
+        const contents = await this.getFile(aboutJsxPath)
+        if (!contents.includes(WoodCoffee.COMPONENTS_LIBRARY_VERSION_HIGHLIGHTER) || !contents.includes(WoodCoffee.SUPER_APP_CLIENT_VERSION_HIGHLIGHTER)) {
+            // 'O arquivo About.jsx baixado, não é um arquivo consistente.'
+            throw new Error('Faltam placeholders para exibicao da versao do components e client')
+        }
+        return true
+    }
+
+    async updateAboutJSXFile(aboutJsxPath, newMiniAppConf) {
+        const superAppClientLibVersion = newMiniAppConf[WoodCoffee.SUPER_APP_CLIENT]
+        const componentsLibVersion = newMiniAppConf[WoodCoffee.MINIAPP_COMPONENTS]
+        const contents = await this.getFile(aboutJsxPath)
+        return new Promise((resolve, reject) => {
+            const replaced = contents
+                .replace(WoodCoffee.COMPONENTS_LIBRARY_VERSION_HIGHLIGHTER, componentsLibVersion)
+                .replace(WoodCoffee.SUPER_APP_CLIENT_VERSION_HIGHLIGHTER, superAppClientLibVersion)
+
+            fs.writeFile(aboutJsxPath, replaced, 'utf-8', function (err) {
+                if (err) {
+                    console.error(err)
+                    reject(err)
+                }
+                resolve()
+            })
+        })
+    }
+
+    getFile(aboutJsxPath) {
+        return new Promise((resolve, reject) => {
+            fs.readFile(aboutJsxPath, 'utf-8', function (err, contents) {
+                if (err) {
+                    console.error(err)
+                    reject(err)
+                }
+                resolve(contents)
+            })
+        })
+    }
+
+    async copyFile(currentPath, destinyPath) {
+        return new Promise((resolve, reject) => {
+            fs.copyFile(currentPath, destinyPath, (error) => {
+                if (error) {
+                    console.error(error)
+                    reject(error)
+                }
+                resolve()
+            })
+        })
+    }
+
+    validateFileName(folderName) {
+        const re = /[<>:"/\\|?*\x00-\x1F]|^(?:aux|con|clock\$|nul|prn|com[1-9]|lpt[1-9])$/i
+        if (re.test(folderName)) {
+            return false
+        }
+        return true
+    }
+
+    verifyFolder(projectName, options) {
+        options = options || {}
+        return new Promise((resolve, reject) => {
+            let projPath = process.cwd()
+            if (!this.validateFileName(projectName)) {
+                return reject(
+                    `O nome do projeto ${projectName} possui caracteres proibidos.`,
+                )
+            }
+            if (projectName) {
+                projPath = path.join(process.cwd(), projectName)
+            }
+            const folder2check = path.join(projPath, 'src')
+            if (!options.supressLog) {
+                console.log('Verificando', folder2check)
+            }
+            if (fs.existsSync(folder2check)) {
+                return reject(
+                    `A pasta ${folder2check} existe, abortando e deixando tudo inalterado.`,
+                )
+            }
+
+            resolve(projPath)
+        })
+    }
+
+    extractZip(localPath, projectPath) {
+        return new Promise((resolve, reject) => {
+            new AdmZip(localPath).extractAllToAsync(
+                /* target path*/ projectPath,
+                /* overwrite*/ true,
+                (err) => {
+                    if (err) {
+                        reject('Erro ao descompactar o boilerplate')
+                        console.log(err)
+                        return
+                    }
+                    console.log('Exemplo gerado.')
+                    resolve()
+                },
+            )
+        })
+    }
+
+    createTempFile() {
+        return new Promise((resolve, reject) => {
+            tmp.file({ prefix: 'eitri-', postfix: '.zip', keep: true }, function (
+                err,
+                localPath,
+            ) {
+                if (err) {
+                    return reject(err)
+                }
+                resolve(localPath)
+            })
+        })
+    }
+
+    downloadFromGithub(boilerplateUrl, projectName, projectPath) {
+        return new Promise((resolve, reject) => {
+            const CMD = `git clone ${boilerplateUrl} ${projectName}`
+            exec(CMD, async (error, stdout, stderr) => {
+                if (error) {
+                    console.error('Não foi possível obter o template remoto. Resolvendo localmente.')
+                    return reject(error)
+                }
+                console.log('Download de template completo.')
+                Promise.resolve(rm(`${projectPath}/.git`, { recursive: true, force: true }))
+                resolve({ stdout: stdout, stderr: stderr })
+            })
+        })
+
+    }
+
+    writeAmeConf(project, conf) {
+        return new Promise((resolve, reject) => {
+
+            conf['version'] = '0.1.0'
+            let confString = `module.exports = ${JSON.stringify(conf, null, 4)}`
+            fs.writeFile(path.join(project.projectPath, 'miniapp.conf.js'), confString, (err) => {
+                if (err) {
+                    return reject(err)
+                }
+                resolve()
+            })
+        })
+    }
+
+    _getLatestLibVersion(libName) {
+        try {
+            const cmd = `npm view ${libName} version`
+            const version = execSync(cmd).toString()
+            return version
+        } catch (error) {
+            console.error(`Não foi possível recuperar a última versão da biblioteca ${libName}.`)
+            throw error
+        }
+    }
+}
+
+module.exports = WoodCoffee

package/src/util/AboutTemplate.jsx

@@ -0,0 +1,14 @@
+<Window>
+    <Group>
+        <Circle icon={require('../assets/images/icon_ame.svg')} />
+        <Spacing size="sm" />
+        <Subtitle fontSize="xs" textAlign="center" color="neutralcolor-darkest">Detalhes desta versão</Subtitle>
+        <View>
+            <Subtitle textAlign="center" fontSize="xxxs" color="neutralcolor-darkest">Este mini-app foi desenvolvido utilizando as seguintes versões:</Subtitle>
+            <Spacing size="sm" />
+            <Paragraph textAlign="center">Versão da biblioteca de componentes: ###COMPONENTS_LIBRARY_VERSION_HIGHLIGHTER###</Paragraph>
+            <Spacing size="sm" />
+            <Paragraph textAlign="center">Versão da API de Super Client: ###SUPER_APP_CLIENT_VERSION_HIGHLIGHTER###</Paragraph>
+        </View>
+    </Group>
+</Window>

package/src/util/UrlUtils.js

@@ -0,0 +1,12 @@
+class UrlUtils {
+    static isUrl(urlString) {
+        try { 
+            return Boolean(new URL(urlString)); 
+        }
+        catch(e){ 
+            return false; 
+        }
+    }
+}
+
+module.exports = UrlUtils

package/src/util/UserLocalCredential.js

@@ -0,0 +1,122 @@
+const fs = require('fs')
+const os = require('os')
+const path = require('path')
+const config = require('config')
+const TrackingEitriAnalytics = require('../service/TrackingEitriAnalytics')
+
+class UserLocalCredential {
+    constructor() {
+        this.miniappFolder = path.join(os.homedir(), '.eitri')
+    }
+
+    _getNewConfigPath(conf = {}) {
+        const defaultConfigPath = path.join(
+            os.homedir(),
+            config.get('signup').get('configFilePath')
+        )
+
+        if (conf?.createCredential && conf?.devUser && conf?.devKey) {
+            return defaultConfigPath
+        }
+
+        if (fs.existsSync(defaultConfigPath)) {
+            return require(defaultConfigPath)
+        }
+        
+        const oldDevConfigPath = path.resolve(
+            os.homedir(),
+            config.get('signup').get('oldConfigFilePath')
+        )
+
+        const miniAppNamePathIndex = oldDevConfigPath.indexOf('.miniapp/');
+        const onlyPath = oldDevConfigPath.substring(0, miniAppNamePathIndex + 9);
+        if (fs.existsSync(oldDevConfigPath)) {
+            fs.renameSync(onlyPath, onlyPath?.replace("/.miniapp", "/.eitri"))
+            return require(defaultConfigPath)
+        }
+
+        let e = new Error(
+            ` Desculpe, parece que não há nenhuma configuração de credencial. \n Por favor, execute o comando "eitri login" no seu terminal.`
+        )
+        e.isSignupError = true
+        throw e
+    }
+
+    fixMiniappCredentialLocation() {
+        const miniAppFolderExist = fs.existsSync(this.miniappFolder)
+        const newConfigPath = this._getNewConfigPath()
+
+
+        if (!miniAppFolderExist) {
+            console.log('Criando pasta .eitri')
+            try {
+                fs.mkdirSync(this.miniappFolder)
+                if (process.env.LOG_LEVEL === 'full')
+                    console.log('Pasta .eitri criada com sucesso.')
+            } catch (error) {
+                console.error(`Erro ao criar a pasta .eitri: ${error}`)
+                throw error
+            }
+        }
+    }
+
+    saveContent(conf) {
+        const configPath = this._getNewConfigPath();
+        const confContent = `module.exports = ${JSON.stringify(conf, null, 4)}`
+        const miniAppFolderExist = fs.existsSync(this.miniappFolder)
+        if (!miniAppFolderExist) {
+            console.log('Criando pasta .eitri')
+            try {
+                fs.mkdirSync(this.miniappFolder)
+                if (process.env.LOG_LEVEL === 'full')
+                    console.log('Pasta .eitri criada com sucesso.')
+            } catch (error) {
+                console.error(`Erro ao crair a pasta .eitri: ${error}`)
+                throw error
+            }
+        }
+        fs.writeFile(configPath, confContent, (err) => {
+            if (err) {
+                console.log('Erro ao salvar a config.')
+                fn('error')
+            } else {
+                console.log(`Credencial salva com sucesso!`)
+            }
+        })
+    }
+
+    async asyncSaveContent(conf) {
+        const newConf = {
+            createCredential: true,
+            ...conf
+        }
+        const configPath = this._getNewConfigPath(newConf);
+        const confContent = `module.exports = ${JSON.stringify(conf, null, 4)}`
+        const miniAppFolderExist = fs.existsSync(this.miniappFolder)
+        if (!miniAppFolderExist) {
+            console.log(' Criando a pasta .eitri...')
+            try {
+                fs.mkdirSync(this.miniappFolder)
+                if (process.env.LOG_LEVEL === 'full')
+                    console.log('Pasta .eitri criada com sucesso.')
+            } catch (error) {
+                console.error(`Erro ao criar a pasta .eitri: ${error}`)
+                throw error
+            }
+        }
+
+        await new Promise(function (resolve){
+            fs.writeFile(configPath, confContent, (err) => {
+                if (err) {
+                    console.log('Erro ao salvar a config.')
+                    fn('error')
+                } else {
+                    console.log(` Credencial salva com sucesso!`)
+                    resolve()
+                }
+            })
+        })
+    }
+}
+
+module.exports = UserLocalCredential