eitri-cli 1.38.0-beta.9 → 1.39.0-beta.1

package/src/service/StarterService.js

@@ -1,31 +0,0 @@
-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, setupConfig, 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 = await factory.create(args, trackingService, watcher, workspace, setupConfig)
-    await starter.startServer()
-}
-
-module.exports = handleStartServer

package/src/service/TagTree.js

@@ -1,101 +0,0 @@
-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

@@ -1,97 +0,0 @@
-const configService = require('./ConfigService')
-const targetEnum = require('../enum/target')
-// eslint-disable-next-line no-unused-vars
-class TargetService{
-    
-    static LIBS_FOR_TARGET = {
-        MOBILE: {
-            bifrost: 'eitri-app-client',
-            luminus: 'eitri-app-components',
-            sdkSupport: 'eitri-app-sdk-support',
-        },
-        MOBILE_NEW: {
-            bifrost: 'eitri-bifrost',
-            luminus: 'eitri-luminus',
-            sdkSupport: 'eitri-app-sdk-support',
-        },
-    }
-    constructor(workspace) {
-        this.workspace = workspace
-        this.conf = configService.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(eitriConf, availableTargets) {
-        const application = availableTargets.find(t => t.name === eitriConf.target || t.id === eitriConf.applicationId)
-        if (application) {
-            return {
-                bifrost: application.superAppClientLibName,
-                luminus: application.componentsLibName,
-                sdkSupport: application.sdkSupportLibName || this.LIBS_FOR_TARGET.MOBILE.sdkSupport
-            }
-        }
-        return this.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

@@ -1,11 +0,0 @@
-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

@@ -1,26 +0,0 @@
-const axios = require('axios')
-const configService = require('./ConfigService')
-const EITRI_ANALYTICS_URL = configService.get('eitriAnalytics')?.url
-const packageJson = require('../../package.json')
-
-class TrackingEitriAnalytics {
-
-    static async sendEvent(input = {eventName: "", userId: "", data: {}}) {
-        const {eventName, data, userId} = input
-
-        const event = {
-            origin: "CLI",
-            eventName,
-            sessionId: process?.env?.["NODE_APP_SESSION_ID"] ?? "",
-            userId,
-            data: {
-                cliVersion: packageJson?.version || "0.0.0",
-               ...data
-            }
-        }
-        await axios.post(EITRI_ANALYTICS_URL, event).catch(_err => null)
-    }
-
-}
-
-module.exports = TrackingEitriAnalytics

package/src/service/TrackingService.js

@@ -1,183 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,118 +0,0 @@
-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)
-                return this.workspace.delete(filePath)
-            }
-            fs.stat(filePath, (err, stat) => {
-                if (err) {
-                    console.error(err)
-                    return
-                }
-                if (stat.isFile()) {
-                    console.log('\x1b[34meitri:Alteraçõ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[94meitri:Forjado em ${result.time} milissegundos\x1b[0m`);
-                                this.trackingService.sendSave(event)
-                            } else {
-                                console.log(`\x1b[94meitri:Transportado 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