eitri-cli 1.0.2

package/src/service/Http.js

@@ -0,0 +1,234 @@
+const axiosCookieJarSupport = require('axios-cookiejar-support').default
+const FileCookieStore = require('tough-cookie-file-store').FileCookieStore
+const CookieJar = require('tough-cookie').CookieJar
+const { v4: uuidv4 } = require('uuid')
+
+const os = require('os')
+const path = require('path')
+const getCliVersion = require('../util/getCliVersion')
+
+const filePath = path.join(os.homedir(), './.eitri.cookie.json')
+const jar = new CookieJar(new FileCookieStore(filePath))
+
+const axios = require('axios').create({ withCredentials: true, jar })
+
+axiosCookieJarSupport(axios)
+
+let canShowLog = true
+
+axios.interceptors.response.use(function (response) {
+    const YELLOW_COLOR = '\x1b[33m'
+    const BLUE_COLOR = '\x1b[94m'
+    const RESET_COLORS = '\x1b[0m'
+    const {warning} = response.data
+    const {greeting} = response.data
+    if(canShowLog) {
+        if(warning) {
+            console.warn(`${YELLOW_COLOR}\nAtenção: ${warning.message}${YELLOW_COLOR}${RESET_COLORS}\n`)
+        }
+        if(greeting) {
+            console.log(`${BLUE_COLOR}\n${greeting.message}${BLUE_COLOR}${RESET_COLORS}\n`)
+        }
+        canShowLog = (warning || greeting) ? false : true
+    }
+    return response
+})
+class Http {
+    constructor(tokenFactory) {
+        this.tokenFactory = tokenFactory
+        this.newTokenAttempt = 0
+    }
+
+    setTokenFactory(tokenFactory) {
+        this.tokenFactory = tokenFactory
+    }
+
+    setToken(token) {
+        this.token = token
+    }
+
+    getCookieSession(url) {
+        return new Promise((resolve, reject) => {
+            jar.getCookies(url, function (err, cookies) {
+                if (err) return reject(err)
+                resolve(cookies.find((cookie) => cookie))
+            })
+        })
+    }
+
+    async post(url, data, headers) {
+        if (!this.token) {
+            this.token = await this.tokenFactory.getToken()
+        }
+        const mergedHeaders = {
+            ...this._getHeader(), ...headers
+        }
+        return await axios.post(url, data, { headers: mergedHeaders })
+    }
+
+    async postForm(url, formData) {
+        if (!this.token) {
+            this.token = await this.tokenFactory.getToken()
+        }
+
+        const headers = {
+            ...this._getHeader(),
+            'Content-Type': `multipart/form-data; boundary=${formData.getBoundary()}`,
+        }
+        return await this._postForm(url, formData, headers)
+    }
+
+    _getHeader() {
+        const tid = uuidv4()
+        return {
+            Authorization: `Bearer ${this.token.accessToken}`,
+            'X-Transaction-Id': tid,
+            'App-Tools-Version': getCliVersion()
+        }
+    }
+
+    __postForm(url, formData, headers, resolve, reject) {
+        axios.post(url, formData, { headers: headers })
+            .then((resp) => resolve(resp.data))
+            .catch((err) => this.rejectErrorPolitely({ err, methodName: '__postForm', url, formData, headers, resolve, reject }))
+    }
+
+    _postForm(url, formData, headers) {
+        return new Promise((resolve, reject) => {
+            this.__postForm(url, formData, headers, resolve, reject)
+        })
+    }
+
+    async delete(url, options) {
+        if (!this.token) {
+            this.token = await this.tokenFactory.getToken()
+        }
+        const headers = this._getHeader()
+        return await this._delete(url, options, headers)
+    }
+
+    __delete(url, data, headers, resolve, reject) {
+        axios.delete(url, { headers: headers, params: data.params })
+            .then((resp) => resolve(resp.data))
+            .catch((err) => this.rejectErrorPolitely({ err, methodName: '__delete', url, data, headers, resolve, reject }))
+    }
+
+    _delete(url, options, headers) {
+        return new Promise((resolve, reject) => {
+            this.__delete(url, options, headers, resolve, reject)
+        })
+    }
+
+    async get(url, options) {
+        options = options || {}
+        if (!this.token) {
+            this.token = await this.tokenFactory.getToken()
+        }
+        const headers = this._getHeader()
+        return await this._get({ url, options, headers })
+    }
+
+    _get(args) {
+        return new Promise((resolve, reject) => {
+            this.__get(args, resolve, reject)
+        })
+    }
+
+    __get(args, resolve, reject) {
+        const mergedHeaders = { ...args.headers, ...args.options.headers} 
+        args.options.headers = mergedHeaders
+        axios
+            .get(args.url, args.options)
+            .then((result) => {
+                resolve(result.data)
+            })
+            .catch((err) => {
+                if (err.isAxiosError) {
+                    this.newTokenAttempt++
+                    if (err.response && err.response.status === 401 && this.newTokenAttempt < 3) {
+                        this.tokenFactory
+                            .getToken()
+                            .then((token) => {
+                                this.token = token
+                                args.headers = this._getHeader()
+                                this.__get(args, resolve, reject)
+                            })
+                            .catch(reject)
+                        return
+                    }
+                    if (this.isError4xxWithMessage(err) || this.isError5xxWithMessage(err)) {
+                        let error = new Error(`\n${err.response.data.error}`)
+                        error.httpStatus = err.response.status
+                        return reject(error)
+                    }
+                }
+                reject(err)
+            })
+    }
+
+    async put(url, data, headers) {
+        data = data || {}
+        if (!this.token) {
+            this.token = await this.tokenFactory.getToken()
+        }
+        const mergedHeaders = { ...this._getHeader(), ...headers }
+        return await this._put(url, data, mergedHeaders)
+    }
+
+    _put(url, data, headers) {
+        return new Promise((resolve, reject) => {
+            this.__put(url, data, headers, resolve, reject)
+        })
+    }
+
+    __put(url, data, headers, resolve, reject) {
+        axios
+            .put(url, data, { headers })
+            .then((result) => resolve(result.data))
+            .catch((err) => this.rejectErrorPolitely({ err, methodName: '__put', url, data, headers, resolve, reject }))
+    }
+
+    rejectErrorPolitely(args) {
+        const { err, methodName, url, data, headers, resolve, reject } = args
+
+        if (process.env.LOG_LEVEL === 'full') console.error('Http.js:rejectErrorPolitely', err)
+
+        if (err.isAxiosError) {
+            this.newTokenAttempt++
+            if (err.response && err.response.status === 401 && this.newTokenAttempt < 3) {
+                this.tokenFactory
+                    .getToken()
+                    .then((token) => {
+                        const newHeaders = this.updateToken(token.accessToken, headers)
+                        this[methodName](url, data, newHeaders, resolve, reject)
+                    })
+                    .catch(reject)
+                return
+            }
+            if (this.isError4xxWithMessage(err) || this.isError5xxWithMessage(err)) {
+                let error = new Error(err.response.data.error)
+                error.httpStatus = err.response.status
+                error.response = { data: err.response.data }
+
+                return reject(error)
+            }
+        }
+        reject(err)
+    }
+
+    isError5xxWithMessage(err) {
+        return err.response && 500 <= err.response.status && err.response.status < 600 && err.response.data && typeof err.response.data.error === 'string'
+    }
+
+    isError4xxWithMessage(err) {
+        return err.response && 400 <= err.response.status && err.response.status < 500 && err.response.data && typeof err.response.data.error === 'string'
+    }
+
+    updateToken(token, headers) {
+        let headersCopy = { ...headers }
+        headersCopy['Authorization'] = `Bearer ${token}`
+        return headersCopy
+    }
+}
+
+module.exports = Http

package/src/service/InviteService.js

@@ -0,0 +1,45 @@
+const config = require('config')
+
+class InviteService {
+
+    constructor(workspace) {
+        this.workspace = workspace
+        this.conf = config.get('managerApi')
+    }
+
+    async findAllPending() {
+        let url = `${this.conf.url}${this.conf.invites.my}`
+        let invites = await this.workspace.http.get(url)
+        return invites.filter(inv => inv.status === 'ACTIVE')
+    }
+
+    async accept(inviteToAccept) {
+        if (!inviteToAccept) {
+            throw new Error('Convite indefinido')
+        }
+        let url = `${this.conf.url}${this.conf.invites.accept}`
+        await this.workspace.http.put(url, inviteToAccept)
+    }
+
+    async sendInvite(slug, email) {
+        let url = `${this.conf.url}${this.conf.invites.send}`
+        await this.workspace.http.post(url, { email, slug })
+    }
+
+    async findAllBySlug(slug) {
+        let url = `${this.conf.url}${this.conf.invites.slug}`.replace(':slug', slug)
+        let invites = await this.workspace.http.get(url)
+        return invites
+    }
+
+    async remove(invite) {
+        if (!invite) {
+            throw new Error('Convite indefinido')
+        }
+        let url = `${this.conf.url}${this.conf.invites.remove}`.replace(':inviteToken', invite.token)
+        await this.workspace.http.delete(url, {})
+    }
+
+}
+
+module.exports = InviteService

package/src/service/ManageEnvService.js

@@ -0,0 +1,10 @@
+class ManageEnvService {
+    async getEnvVariables(workspace, url, miniConf, env, email, fileName) {
+        const { slug, version } = miniConf
+        const mountedQuery = `env=${env}&slug=${slug}&miniAppVersion=${version}&fileName=${fileName}&email=${email}`
+        const result = await workspace.http.get(`${url}/env?${mountedQuery}`)
+        return result
+    }
+}
+
+module.exports = ManageEnvService

package/src/service/MiniLog.js

@@ -0,0 +1,132 @@
+const io = require('socket.io-client')
+const chalk = require('chalk')
+
+class MiniLog {
+    constructor(config) {
+        if (!config) {
+            throw new Error('MiniLog config is required')
+        }
+        this._config = config
+        this.verbose = false
+    }
+
+    connect(roomName, silentOnConnect) {
+        return new Promise((resolve, reject) => {
+            const socket = this.createSocket()
+            socket.on('connect', () => {
+                if(!silentOnConnect) console.log('Construindo para ', roomName)
+                socket.emit('joinRoom', roomName)
+                resolve()
+            })
+            socket.on('connect_error', (e) => {
+                if(silentOnConnect) console.error('Não foi possível contectar ao compilador', roomName)
+                else console.error('Não foi possível contectar ao compilador', roomName, `${this._config.url} ${this._config.path}`)
+                reject(e)
+            })
+            socket.on('onLog', (data) => {
+                this.printLog(data)
+            })
+            this.socket = socket
+        })
+    }
+    //TODO: ESSE MÉTODO DEVE SER APAGADO, QUANDO NÃO EXISTIR MAIS O COMANDO PUBLISH
+    awaitForPublish() {
+        return new Promise((resolve, reject) => {
+            this.socket.on('onLog', (event) => {
+                if (!event.publish) {
+                    return
+                }
+                if (event.publish.ok) {
+                    resolve(event)
+                } else {
+                    reject(new Error(event.publish.error))
+                }
+            })
+        })
+    }
+
+    awaitForBuild() {
+        return new Promise((resolve, reject) => {
+            this.socket.on('onLog', (event) => {
+                if (!event.publish) {
+                    return
+                }
+                if (event.publish.ok) {
+                    resolve(event)
+                } else {
+                    reject(new Error(event.publish.error))
+                }
+            })
+        })
+    }
+
+    awaitForPushVersion() {
+        return new Promise((resolve, reject) => {
+            this.socket.on('onLog', (event) => {
+                if (!event.publish) {
+                    return
+                }
+                if (event.publish.ok) {
+                    resolve(event)
+                } else {
+                    reject(new Error(event.publish.error))
+                }
+            })
+        })
+    }
+
+    createSocket() {
+        if (this._config.path) {
+            return io.connect(this._config.url, { path: this._config.path, transport: 'websocket' })
+        } else {
+            return io(this._config.url)
+        }
+    }
+
+    format2JSON(str) {
+        let parsedToJSON
+
+        try {
+            parsedToJSON = JSON.parse(str)
+        } catch (e) {
+            return undefined
+        }
+
+        return parsedToJSON
+    }
+
+    printLog(data) {
+        if (typeof data.msg === 'undefined') {
+            return
+        }
+        if (
+            typeof data.msg === 'string' &&
+            data.msg.includes(
+                'Download the React DevTools for a better development experience'
+            )
+        ) {
+            return
+        }
+
+        if (this.verbose) {
+            console.log(`\x1b[34meitri ${data.userAgent}\n\x1b[0m\x1b[90m${data.msg}\x1b[0m`);
+        }
+
+        if (/^START RequestId/.test(data.msg)) {
+            let msg = data.msg
+                .replace(/Version: \$LATEST/, '')
+                .split('\n')
+                .map((line) => line.replace(/^[0-9]+[^\t]+\t.*?\t/, ''))
+                .join('\n')
+            console.log(chalk.cyan(msg))
+        } else {
+            // A propriedade userFriendlyMessage deve ser tratada pelo miniapp. Logaremos da forma como o miniapp nos fornecer o objeto.
+            console.log(`\x1b[34meitri:\x1b[0m\x1b[97m${data.msg}\x1b[0m`);
+        }
+        if (data.stopCLI) {
+            process.exit(1)
+        }
+    }
+}
+
+module.exports = MiniLog

package/src/service/QRCodeFactory.js

@@ -0,0 +1,43 @@
+const tmp = require('tmp')
+const qrcode = require('qrcode')
+
+// Fabrica de QR code :-)
+class QRCodeFactory {
+    async create(data) {
+        console.log('==================================================')
+        console.log('Utilize o QR-Code para iniciar o seu eitri-app')
+        console.log('É importante utilizar o leitor de QR-Code do')
+        console.log('aplicativo à qual destina-se o seu eitri-app')
+        console.log('==================================================')
+        let qrCodeTempPath = await this.tempFile()
+        await this.createQRCodeImage(qrCodeTempPath, data)
+        return qrCodeTempPath
+    }
+
+    createQRCodeImage(qrCodeTempPath, data) {
+        return new Promise((resolve, reject) => {
+            qrcode.toFile(qrCodeTempPath, data, (err) => {
+                if (err) {
+                    return reject(err)
+                }
+                resolve()
+            })
+        })
+    }
+
+    tempFile() {
+        return new Promise((resolve, reject) => {
+            tmp.file(
+                { prefix: 'eitri-qrcode-', postfix: '.png', keep: true },
+                function (err, tempPath) {
+                    if (err) {
+                        return reject(err)
+                    }
+                    resolve(tempPath)
+                }
+            )
+        })
+    }
+}
+
+module.exports = QRCodeFactory

package/src/service/Server.js

@@ -0,0 +1,239 @@
+const fs = require('fs')
+const open = require('open')
+const path = require('path')
+const config = require('config')
+const { URL } = require('url')
+const Express = require('express')
+const rateLimit = require('express-rate-limit')
+const host = 'localhost'
+const port = process.env.AME_APP_TOOLS_PORT || 3333
+const TERMINAL_PRINTER_NAME = 'terminal'
+let serverInstance
+const requestListenerHelper  = require('../helpers/request-listener-helper')
+const CliLogin = require('./CliLogin')
+
+
+const expressRateLimiter = rateLimit({
+    windowMs: 15 * 60 * 1000,
+    max: 100, 
+    standardHeaders: true,
+    legacyHeaders: false,
+})
+class Server {
+    static stop(args) {
+        try {
+            if (serverInstance) {
+                serverInstance.close()
+            }
+        } catch (e) {
+            if (args.verbose) {
+                console.log(`Erro ao parar servidor local: ${e.message}`)
+            }
+        }
+    }
+
+    static startServer(args) {
+        Server.stop(args)
+        const { qrCodePath, qrPrinter, verbose } = args
+        const requestListener = function (req, res) {
+            if (req.url === '/') {
+                res.setHeader('Content-Type', 'text/html; charset=utf-8')
+                res.writeHead(200)
+
+                let readStream = fs.createReadStream(
+                    path.resolve(__dirname, '../view/index.html')
+                )
+                readStream.pipe(res)
+            } else {
+                res.setHeader('Content-Type', 'image/png')
+                res.writeHead(200)
+
+                let readStream = fs.createReadStream(qrCodePath)
+                readStream.pipe(res)
+            }
+        }
+
+        serverInstance = Express().disable('x-powered-by')
+        serverInstance.use(expressRateLimiter)
+        serverInstance.use(requestListener)
+
+        serverInstance.listen(port, host, () => {
+            // Prioridade no printer informado pelo argumento do programa, depois o que foi informado na variavel de ambiente
+            if (!qrPrinter && !process.env.AAT_QRCODE_PRINTER) {
+                open(`http://${host}:${port}`)
+            } else if (qrPrinter && qrPrinter !== TERMINAL_PRINTER_NAME) {
+                open(`http://${host}:${port}`, { app: qrPrinter })
+            } else if (
+                process.env.AAT_QRCODE_PRINTER &&
+                process.env.AAT_QRCODE_PRINTER !== TERMINAL_PRINTER_NAME
+            ) {
+                open(`http://${host}:${port}`, {
+                    app: process.env.AAT_QRCODE_PRINTER,
+                })
+            }
+            if (verbose) {
+                console.log(`Server is running on http://${host}:${port}`)
+            }
+        })
+    }
+
+    static startServerMinhaContaEmulator(args) {
+        Server.stop(args)
+        const { browser, verbose, bootstrapUrl, slug, http: workspaceHttp } = args
+        const ameSuperAppWebConfig = config.get('ameSuperAppWeb')
+        
+        /**
+         * Paramêtros do request listener definidos para o create server
+         * @param {Express.Request} req 
+         * @param {Express.Response} res 
+         * @returns 
+         */
+        const requestListener = function (req, res) {
+            if (req.url.startsWith('/workspace')) {
+                const url = `${config.workspace.url}${req.url}`
+                workspaceHttp
+                    .get(url)
+                    .then((workspaceRes) => {
+                        res.header('Content-Type', 'text/html; charset=utf-8')
+                        res.status(200).send(workspaceRes)   
+                    })
+                    .catch((e) => {
+                        console.log(e)
+                    })
+            } else {
+                // res.header('Content-Type', 'text/html; charset=utf-8')
+                // res.writeHead(200)
+
+                let data = fs.readFileSync(
+                    path.resolve(__dirname, '../view/ame_minha_conta_emulator.html'),
+                    'utf8'
+                )
+                const _url = new URL(bootstrapUrl)
+                const finalUrl = bootstrapUrl.replace(
+                    _url.origin,
+                    `http://localhost:${port}`
+                )
+
+                data = data.replace('##ENVIRONMENT##', process.env.NODE_ENV === 'dev' ? 'dev' : 'hml' )
+                data = data.replace(
+                    '##AME_SUPER_APP_SRC##',
+                    ameSuperAppWebConfig.url
+                )
+                data = data.replace('##IFRAME_SRC##', finalUrl)
+                //TODO configurar o slug do mini-app corrente
+                data = data.replace('##SLUG##', slug)     
+                return res.send(data)
+            }
+        }
+        serverInstance = Express().disable('x-powered-by')
+        serverInstance.use(expressRateLimiter)
+        serverInstance.use(requestListener)
+
+        serverInstance.listen(port, host, () => {
+            open(`http://${host}:${port}`, { app: browser })
+            if (verbose) {
+                console.log(`Server is running on http://${host}:${port}`)
+            }
+        })
+    }
+
+    static startServerEmulator(args) {
+        Server.stop(args)
+        const { browser, verbose, bootstrapUrl, slug, http: workspaceHttp } = args
+        const ameSuperAppWebConfig = config.get('ameSuperAppWeb')
+        console.log(bootstrapUrl)
+        
+        const requestListener = function (req, res) {
+            if (req.url.startsWith('/workspace')) {
+                const url = `${config.workspace.url}${req.url}`
+                return requestListenerHelper(workspaceHttp, req.url, res, url)
+            } else {
+                res.setHeader('Content-Type', 'text/html; charset=utf-8')
+                res.writeHead(200)
+
+                let data = fs.readFileSync(
+                    path.resolve(__dirname, '../view/emulator.html'),
+                    'utf8'
+                )
+                const _url = new URL(bootstrapUrl)
+                const finalUrl = bootstrapUrl.replace(
+                    _url.origin,
+                    `http://localhost:${port}`
+                )
+
+                data = data.replace('##ENVIRONMENT##', process.env.NODE_ENV === 'dev' ? 'dev' : 'hml' )
+                data = data.replace('##IFRAME_SRC##', finalUrl)
+                data = data.replace(
+                    '##AME_SUPER_APP_SRC##',
+                    ameSuperAppWebConfig.url
+                )
+                //TODO configurar o slug do mini-app corrente
+                data = data.replace('##SLUG##', slug)
+
+                res.send(data)
+            }
+        }
+
+        serverInstance = Express().disable('x-powered-by')
+        serverInstance.use(expressRateLimiter)
+        serverInstance.use(requestListener)
+
+        serverInstance.listen(port, host, () => {
+            open(`http://${host}:${port}`, { app: browser })
+            if (verbose) {
+                console.log(`Server is running on http://${host}:${port}`)
+            }
+        })
+    }
+
+    static startMiniAppProxyServerAndOpenTarget(args) {
+        Server.stop(args)
+        const { verbose, openPath, http: workspaceHttp } = args
+        /**
+         * Paramêtros do request listener definidos para o create server
+         * @param {Express.Request} req 
+         * @param {Express.Response} res 
+         * @returns 
+         */
+        const requestListener = function (req, res) {
+            let url = `${config.workspace.url}${req.url}`
+            return requestListenerHelper(workspaceHttp, req.url, res, url, verbose)
+        }
+
+        serverInstance = Express().disable('x-powered-by')
+        serverInstance.use(expressRateLimiter)
+        serverInstance.use(requestListener)
+        serverInstance.listen(port, host, () => {
+            if (verbose) {
+                console.log(`Server is running on http://${host}:${port}`)
+            }
+            open(openPath)
+        })
+    }
+
+    static startCliLogin(args) {
+        Server.stop(args)
+        const verbose = args?.verbose || ""
+
+        serverInstance = Express().disable('x-powered-by')
+        serverInstance.use(expressRateLimiter)
+        serverInstance.listen(port, host, () => {
+            if (verbose) {
+                console.log(`Server is running on http://${host}:${port}`)
+            }
+        })
+
+        serverInstance.get('/cli-login', async (req, res) => {
+            const {email, credential} = req?.query || {}
+            res.send('hello world')
+            await new CliLogin().saveCredentials({
+                email,
+                credential
+            })
+        })
+
+        return {host, port}
+    }
+}
+
+module.exports = Server