eitri-cli 1.0.2

package/src/service/StarterService.js

@@ -0,0 +1,31 @@
+const QRCodeStarterFactory = require('./factories/QRCodeStarterFactory')
+const DoubtsStarterFactory = require('./factories/DoubtsStarterFactory')
+const WebStarterFactory = require('./factories/WebStarterFactory')
+
+
+const strategy = require('./GATrackingStrategy')
+async function handleStartServer(args, trackingService, watcher, workspace, factoryName, targetConfig, platform) {
+    const factories = {
+        mobile: new QRCodeStarterFactory(),
+        web: new WebStarterFactory(),
+        DOUBTS: new DoubtsStarterFactory()
+    }
+
+    const factory = platform ? factories[platform] : factories[factoryName]    
+    
+    if(!factory){
+        throw new Error('É necessário definir um valor válido, para o target,  no miniapp.conf.js.')
+    }
+
+    let libsInfoForGA 
+    if(strategy[factoryName]){
+        libsInfoForGA = strategy[factoryName](workspace.getMiniConf())
+        args['libsInfoForGA'] = libsInfoForGA
+    }
+
+
+    const starter = factory.create(args, trackingService, watcher, workspace, targetConfig)
+    await starter.startServer()
+}
+
+module.exports = handleStartServer

package/src/service/TagTree.js

@@ -0,0 +1,101 @@
+const fs = require('fs')
+const path = require('path')
+const cheerio = require('cheerio')
+
+const TAG_EXT = '.jsx'
+const extRegExp = new RegExp(`${TAG_EXT}$`)
+
+class TagTree {
+    async tagsFilesSorted(tagsPath) {
+        let tagMap = await this.buildTagMap(tagsPath)
+        let stack = [],
+            visited = {}
+        for (let tagName in tagMap) {
+            if (!visited[tagName]) {
+                this.deepFirstSearch(tagMap[tagName], visited, stack)
+            }
+        }
+        return stack.map(tagObj => tagObj.fileName)
+    }
+
+    deepFirstSearch(tagObj, visited, stack) {
+        visited[tagObj.name] = true
+        tagObj.children.forEach(childTagObj => {
+            if (!visited[childTagObj.name]) {
+                this.deepFirstSearch(childTagObj, visited, stack)
+            }
+        })
+        stack.push(tagObj)
+    }
+
+    async buildTagMap(tagsPath) {
+        let tagMap = {}
+        let files = await this.listFiles(tagsPath, TAG_EXT)
+        for (let i = 0; i < files.length; i++) {
+            let fileName = files[i]
+            let htmlContent = await this.readTagContent(tagsPath, fileName)
+            let tags = this.extractTagsFromContent(htmlContent)
+            let tagName = fileName.replace(extRegExp, '')
+            tagMap[tagName] = {
+                name: tagName,
+                fileName: fileName,
+                childrenNames: tags.filter(tag => tag !== tagName),
+                children: []
+            }
+        }
+        for (let tagName in tagMap) {
+            let tagObj = tagMap[tagName]
+            tagObj.childrenNames.forEach(tag => {
+                let child = tagMap[tag]
+                if (child) {
+                    tagObj.children.push(child)
+                }
+            })
+            delete tagObj['childrenNames']
+        }
+        return tagMap
+    }
+
+    readTagContent(tagsPath, fileName) {
+        return new Promise((resolve, reject) => {
+            fs.readFile(path.resolve(tagsPath, fileName), 'utf8', (err, data) => {
+                if (err) {
+                    return reject(err)
+                }
+                resolve(data)
+            })
+        })
+    }
+
+    listFiles(tagsPath, extension) {
+        return new Promise((resolve, reject) => {
+            fs.exists(tagsPath, function(exists) {
+                if (!exists) {
+                    return resolve([])
+                }
+                fs.readdir(tagsPath, function(err, files) {
+                    if (err) {
+                        return reject(err)
+                    }
+                    files = files.filter(
+                        fileName => path.extname(fileName) === extension
+                    )
+                    resolve(files)
+                })
+            })
+        })
+    }
+
+    extractTagsFromContent(htmlContent) {
+        let $ = cheerio.load(htmlContent, { xml: { lowerCaseTags: false } })
+        let tags = {}
+        let ignore = { html: true, head: true, body: true, br: true }
+        $('*').each((i, el) => {
+            if (ignore[el.tagName.toLowerCase()]) return true
+            tags[el.tagName] = true
+        })
+        return Object.keys(tags).sort()
+    }
+}
+
+module.exports = TagTree

package/src/service/TargetService.js

@@ -0,0 +1,97 @@
+const config = require('config')
+const targetEnum = require('../enum/target')
+// eslint-disable-next-line no-unused-vars
+
+const LIBS_FOR_TARGET = {
+    MOBILE: {
+        superApp: 'eitri-app-client',
+        components: 'eitri-app-components',
+        sdkSupport: 'eitri-app-sdk-support',
+    },
+    WEB: {
+        superApp: 'eitri-app-client-web',
+        components: 'eitri-miniapp-components-web',
+        sdkSupport: 'eitri-app-sdk-support',
+    },
+}
+class TargetService{
+    constructor(workspace) {
+        this.workspace = workspace
+        this.conf = config.get('managerApi')
+        this.trustedMiniappTarget = null
+    }
+
+    async getTarget() {
+        if (this.trustedMiniappTarget) {
+            return this.trustedMiniappTarget
+        }
+        try{
+            const miniConf = this.workspace.getMiniConf()
+            let url = `${this.conf.url}${this.conf.miniapp.miniAppsPath}/${miniConf.slug}`
+            let miniapp = await this.workspace.http.get(url)
+            this.trustedMiniappTarget = miniapp.target
+            return this.trustedMiniappTarget
+
+        }catch(e){
+            throw new Error('Não identificamos um target válido: ' + e.message)
+        }        
+    }
+
+    static getLibsFromMiniConf(miniConf, availableTargets) {
+        const target = availableTargets.find(t => t.name === miniConf.target)
+        if (target) {
+            return {
+                superApp: target.superAppClientLibName,
+                components: target.componentsLibName,
+                sdkSupport: target.sdkSupportLibName || LIBS_FOR_TARGET.MOBILE.sdkSupport
+            }
+        }
+        return LIBS_FOR_TARGET.MOBILE
+    }
+
+    async getLibs() {
+        let target = await this.getTarget()
+        const availableTargets = await this.workspace.availableTargets()
+        const targetExists = availableTargets.find(t => t.name === target)
+        if (!targetExists) {
+            throw new Error('Target inválido')
+        }
+        return targetExists
+    }
+
+    async getAppConfExampleSnippet() {
+        let target = await this.getTarget()
+        let libs = await this.getLibs()
+        const libsSnippet = '' +
+`  // Versao dos componentes
+  "${libs.components}": "0.0.0",
+
+  // Versao do SDK
+  "${libs.superApp}": "0.0.0",` // close string
+
+
+        const targetSnippet = '' +
+`
+
+  // Target
+  "target": "${target}"` // close string
+
+        let returnString = libsSnippet
+        if (target === targetEnum.AME_EMPRESAS_WEB || target === targetEnum.AME_MINHA_CONTA_WEB) {
+            returnString += targetSnippet
+        }
+        return returnString
+    }
+
+    /**
+     * 
+     * @returns {Promise<Target[]>}
+     */
+    async getTargets() {
+        const targets = await this.workspace.availableTargets()
+        return targets
+    }
+
+}
+
+module.exports = TargetService

package/src/service/TrackService.js

@@ -0,0 +1,11 @@
+module.exports = {
+    track: async function(miniConf, trackingService, libs) {
+        let event = {
+            ...libs,
+            miniAppSlug: miniConf.slug,
+            miniAppVersion: miniConf.version,
+            timeMs: 0,
+        }
+        await trackingService.sendStart(event)
+    }
+}

package/src/service/TrackingEitriAnalytics.js

@@ -0,0 +1,32 @@
+const axios = require('axios')
+const debug = require('debug')('ame-app-tools:TrackingService')
+const config = require('config')
+const EITRI_ANALYTICS_URL = config.get('eitriAnalytics')?.url
+
+class TrackingEitriAnalytics {
+
+    static async sendEvent(input = {command: "", success: true, data: {}, errorMessage: ""}) {
+
+        try {
+            const event = {
+                command: `${input?.command}`,
+                success: `${input?.success}`,
+                data: {
+                    ...(input?.data && typeof input?.data === "object" && !Object.keys(input?.data).length == 0) ? input?.data : undefined
+                }
+            }
+
+            if (input?.errorMessage && typeof input?.errorMessage === "string") {
+                event["errorMessage"] = input?.errorMessage?.replace("'", "")
+            }
+
+            await axios.post(EITRI_ANALYTICS_URL, event)
+        } catch (e) {
+            debug('Erro ao enviar evento ao Eitri Analytics', e?.message)
+        }
+
+    }
+
+}
+
+module.exports = TrackingEitriAnalytics

package/src/service/TrackingService.js

@@ -0,0 +1,183 @@
+const path = require('path')
+const axios = require('axios')
+const os = require('os')
+const TRACKING_ID = 'UA-98713437-6'
+const packageJson = require(path.resolve(__dirname, '..', '..', 'package.json'))
+const debug = require('debug')('eitri:TrackingService')
+const GA_URL = 'https://www.google-analytics.com/collect'
+
+class TrackingService {
+
+    constructor(blindGuardian, opts) {
+        let options = opts || {}
+        this.blindGuardian = blindGuardian
+        try {
+            this._clientId = this.blindGuardian.readClientCredentials().client_id
+        } catch(e) {
+            if (options.ignoreCredentialError) {
+                this._clientId = '58f9699a-ef9b-4b02-b406-c43f0e41738a'
+            } else {
+                throw e
+            }
+        }
+    }
+
+    getUserAgent() {
+        if (os.type() === 'Linux') {
+            return 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Ubuntu Chromium/83.0.4103.61 Chrome/83.0.4103.61 Safari/537.36'
+        }
+        if (os.type() === 'Windows_NT') {
+            return 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/42.0.2311.135 Safari/537.36 Edge/12.246'
+        }
+        if (os.type() === 'Darwin') {
+            return 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_2) AppleWebKit/601.3.9 (KHTML, like Gecko) Version/9.0.2 Safari/601.3.9'
+        }
+        return 'axios/0.19.2'
+    }
+
+    async _send2GA(trackingId, documentLocation, timeMs) {
+        try {
+            const config = { headers: { 'User-Agent': this.getUserAgent() } }
+            config.params = {
+                v: '1',
+                t: 'pageview',
+                tid: trackingId,
+                dl: documentLocation,
+                cid: this._clientId,
+
+                // Page Load Time
+                plt: timeMs,
+
+                z: Math.round(Date.now() / 1000),
+            }
+            await axios.get(GA_URL, config)
+        } catch (e) {
+            debug('Erro ao enviar tracking de pageview', e.message)
+        }
+    }
+    
+    async _sendError2GA(trackingId, documentLocation, error) {
+        try {
+            let errorMessage
+            const config = { headers: { 'User-Agent': this.getUserAgent() } }
+            if (typeof error === 'string') {
+                errorMessage = error
+            } else if (typeof error === 'object') {
+                errorMessage = error.message
+            } else {
+                errorMessage = `Tipo de erro nao suportado: ${typeof error}`
+            }
+            let source = 'no source'
+            if (typeof error === 'object' && error.stack) {
+                source = error.stack.split('\n')[1].trim().replace(/\/.+\//g, '')
+                source = `${errorMessage} ${source}`
+            }
+            config.params = {
+                v: 1,
+                t: 'exception', // exception nao aparece em real time :-(
+                exd: source,
+                exf: 0,
+                dl: documentLocation,
+                dt: errorMessage,
+                tid: trackingId,
+                cid: this._clientId,
+                z: Math.round(Date.now() / 1000),
+            }
+    
+            await axios.get(GA_URL, config)
+        } catch (e) {
+            debug('Erro ao enviar tracking de erro', e.message)
+        }
+    }
+    
+    async _sendEvent2GA(trackingId, documentLocation, event) {
+        try {
+            const config = { headers: { 'User-Agent': this.getUserAgent() } }
+            config.params = {
+                v: 1,
+                t: 'event', // exception nao aparece em real time :-(
+                ec: event.category,
+                ea: event.action,
+                el: event.label,
+                ev: event.value || 0,
+                dl: documentLocation,
+                dt: 'EventDt',
+                tid: trackingId,
+                cid: this._clientId,
+                z: Math.round(Date.now() / 1000),
+            }
+    
+            await axios.get(GA_URL, config)
+        } catch (e) {
+            debug('Erro ao enviar tracking de evento', e.message)
+        }
+    }
+
+    async sendError(error) {
+        let documentLocation = [
+            `${process.env.NODE_ENV}`,
+            `v${packageJson.version}`
+        ].join('/') + '/'
+        await this._sendError2GA(TRACKING_ID, documentLocation, error)
+    }
+
+    async sendStart(event) {
+        await this.sendGeneric(event, 'start')
+    }
+
+    async sendSave(event) {
+        await this.sendGeneric(event, 'save')
+    }
+
+    async sendCompile(event) {
+        await this.sendGeneric(event, 'compile')
+    }
+
+    //TODO: ESSE MÉTODO DEVE SER APAGADO, QUANDO NÃO EXISTIR MAIS O COMANDO PUBLISH
+    async sendPublish(event) {
+        await this.sendGeneric(event, 'publish')
+    }
+
+    async sendBuild(event) {
+        await this.sendGeneric(event, 'build')
+    }
+
+    async sendPushedVersion(event) {
+        await this.sendGeneric(event, 'push-version')
+    }
+
+    async sendSignup() {
+        const eventName = 'signup'
+        let documentLocation = [
+            `${process.env.NODE_ENV}`,
+            `v${packageJson.version}`
+        ].join('/') + '/'
+        await this._send2GA(TRACKING_ID, documentLocation, 0)
+        await this._sendEvent2GA(TRACKING_ID, documentLocation, {
+            category: eventName,
+            action: eventName
+        })
+    }
+
+    async sendGeneric(event, eventName) {
+        let documentLocation = [
+            `${process.env.NODE_ENV || 'default'}`,
+            `v${packageJson.version}`,
+            event.componentsVersion ? `c${event.componentsVersion}` : `web_c${event.webComponentsVersion}`,
+            event.superClientVersion? `s${event.superClientVersion}` : `web_s${event.webSuperClientVersion}`,
+            // 'e', eventName,
+            'ma', event.miniAppSlug,
+            `m${event.miniAppVersion}`
+        ].join('/') + '/'
+        await this._send2GA(TRACKING_ID, documentLocation, event.timeMs || 0)
+        await this._sendEvent2GA(TRACKING_ID, documentLocation, {
+            category: eventName,
+            action: eventName,
+            label: event.miniAppSlug,
+            value: event.timeMs
+        })
+    }
+
+}
+
+module.exports = TrackingService

package/src/service/ValidateResult.js

@@ -0,0 +1,57 @@
+class ValidateResult {
+    constructor(errors) {
+        this.errors = errors
+    }
+
+    addError(msg) {
+        this.errors.push(msg)
+    }
+
+    getErrors() {
+        return this.errors
+    }
+
+    isSuccess() {
+        return this.errors.length == 0
+    }
+
+    showExample() {
+        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",
+
+// Versao dos componentes
+"eitri-app-components": "0.0.0",
+
+// Versao do SDK
+"eitri-app-client": "0.0.0",
+};
+    
+    
+    `
+        )
+    }
+}
+
+module.exports = ValidateResult

package/src/service/Watcher.js

@@ -0,0 +1,119 @@
+const fs = require('fs')
+const nodeWatch = require('node-watch')
+const WatcherOpts = require('../enum/WatcherOpts')
+
+class Watcher {
+    constructor(workspace, hashFolder, trackingService) {
+        this.workspace = workspace
+        this.hashFolder = hashFolder
+        this.trackingService = trackingService
+    }
+
+    getFolder2Watch() {
+        return this.workspace.folder2watch
+    }
+
+    start() {
+        console.log('\x1b[1m\x1b[32mEitri está observando a pasta abaixo:\x1b[0m');
+        console.log(this.getFolder2Watch(), ',', ...this.workspace.getResourceFolder2Watch())
+        this.mkdirs(this.getFolder2Watch())
+        const miniConf = this.workspace.getMiniConf()
+        nodeWatch(this.getFolder2Watch(), { recursive: true }, (evt, name) => {
+            const filePath = name.replace(/\\/g, '/')
+            if (evt === 'remove') {
+                console.log('Apagando', name)
+                this.workspace.delete(filePath)
+                return
+            }
+            fs.stat(filePath, (err, stat) => {
+                if (err) {
+                    console.error(err)
+                    return
+                }
+                if (stat.isFile()) {
+                    console.log('\x1b[34mAlterações em: %s\x1b[0m', filePath)
+                    this.workspace
+                        .upsert(filePath, { why: WatcherOpts.SAVE })
+                        .then((result) => {
+                            let event = {
+                                superClientVersion: miniConf['eitri-app-client'],
+                                componentsVersion: miniConf['eitri-app-components'],
+                                miniAppSlug: miniConf.slug,
+                                miniAppVersion: miniConf.version,
+                                timeMs: result.time,
+                            }
+                            if (result.relativePath === '/folder.hash') {
+
+                                console.log(`\x1b[94mForjado em ${result.time} milissegundos\x1b[0m`);
+                                this.trackingService.sendSave(event)
+                            } else {
+                                console.log(`\x1b[94mTransportado em ${result.time} milissegundos\x1b[0m`);
+                                this.trackingService.sendCompile(event)
+                            }
+                            return this.hashFolder.updateHashFile()
+                        })
+                        .catch((err) => {
+                            if (err.isAxiosError && err.response && err.response.status === 403) {
+                                console.error('\nERRO: Credenciais expiradas')
+                            } else if (err.response && err.response.data && err.response.data.friendlyMessage) {
+                                console.error(`\nERRO: ${err.response.data.friendlyMessage}`)
+                            } else if (err.message) {
+                                console.error(`\nERRO: ${err.message}`)
+                            } else {
+                                console.error('\nErro inesperado [Watcher.start]')
+                            }
+                        })
+                }
+            })
+        })
+
+        const folders = this.workspace.getResourceFolder2Watch()
+        folders.forEach(folder =>
+            nodeWatch(folder, { recursive: true }, (evt, name) => {
+                this._handleWatch(evt, name)
+            })
+        )
+    }
+
+    mkdirs(dirname) {
+        return new Promise((resolve, reject) => {
+            fs.mkdir(dirname, { recursive: true }, (err) => {
+                if (err) {
+                    return reject(err)
+                }
+                resolve()
+            })
+        })
+    }
+
+    _handleWatch(evt, name) {
+        const filePath = name.replace(/\\/g, '/')
+        if (evt === 'remove') {
+            console.log('Apagando', name)
+            this.workspace.delete(filePath)
+            return
+        }
+        fs.stat(filePath, (err, stat) => {
+            if (err) {
+                console.error(err)
+                return
+            }
+            if (stat.isFile()) {
+                console.log('Arquivo %s alterado.', filePath)
+                this.workspace
+                    // o uso de forceTranspile permite  que transpilemos independente de alterações no hash
+                    .upsert(filePath, { why: 'save', forceTranspile: 'true' })
+                    .then((result) => console.log(`Salvo ${result.time}ms`))
+                    .catch((err) => {
+                        if (err && err.message) {
+                            console.log(err.message)
+                        } else {
+                            console.log('Erro inesperado [Watcher.start]')
+                        }
+                    })
+            }
+        })
+    }
+}
+
+module.exports = Watcher