eitri-cli 1.0.2

package/src/cmd/version.js

@@ -0,0 +1,29 @@
+const path = require('path')
+const { execSync } = require('child_process')
+
+
+/**
+ * Loga a versao de um pacote npm
+ */
+function version() {
+    let packageJson = require(path.resolve(__dirname, '..', '..', 'package.json'))
+    let publishedVersion = getVersion(packageJson.name)
+    if (packageJson.version !== publishedVersion) {
+        console.log(
+            `\n\t> Você está usando a versão ${packageJson.version}, temos uma nova versão: ${publishedVersion}!`
+        )
+        console.log(
+            `\t> Para atualizar use o comando:\n\n\t ${packageJson.name} self-update\n`
+        )
+    } else {
+        console.log(`\tVersao atual: ${packageJson.version}`)
+    }
+}
+
+function getVersion(npmPackage) {
+    return execSync(`npm show ${npmPackage} version`)
+        .toString()
+        .trim()
+}
+
+module.exports = {version, getVersion}

package/src/enum/WatcherOpts.js

@@ -0,0 +1,3 @@
+module.exports = {
+    SAVE: 'save'
+}

package/src/enum/target.js

@@ -0,0 +1,6 @@
+module.exports = {
+    AME_DIGITAL_MOBILE: 'AME_DIGITAL_MOBILE',
+    AME_EMPRESAS_WEB: 'AME_EMPRESAS_WEB',
+    AME_MINHA_CONTA_WEB: 'AME_MINHA_CONTA_WEB',
+
+}

package/src/helpers/request-listener-helper.js

@@ -0,0 +1,55 @@
+const IMAGES_FORMAT = ['.png', '.jpg', '.jpeg', '.gif']
+const SVG_FORMAT = '.svg'
+
+/**
+ * @param {*} workspaceHttp 
+ * @param {string} requestUrl 
+ * @param {Express.Response} response
+ * @param {string} workspaceUrl
+ * @param {boolean} verbose
+ */
+function requestListenerHelper(workspaceHttp, requestUrl, response, workspaceUrl, verbose) {
+    const isImage = IMAGES_FORMAT.find(fmt => requestUrl.endsWith(fmt))
+    if(isImage) {
+        workspaceHttp
+            .get(workspaceUrl, {
+                responseType: 'arraybuffer' 
+            })
+            .then((workspaceRes) => {
+                return response.send(workspaceRes)
+            })
+            .catch((e) => {
+                if(verbose) {
+                    console.log(e)
+                }
+            })
+    }
+    else if(requestUrl.endsWith(SVG_FORMAT)) {
+        workspaceHttp
+            .get(workspaceUrl)
+            .then((workspaceRes) => {
+                response.type('image/svg+xml').send(workspaceRes)
+            
+            })
+            .catch((e) => {
+                if(verbose) {
+                    console.log(e)
+                }
+            })
+    }
+    else {
+        workspaceHttp
+            .get(workspaceUrl)
+            .then((workspaceRes) => {
+                response.send(workspaceRes)
+
+            })
+            .catch((e) => {
+                if(verbose) {
+                    console.log(e)
+                }
+            })
+    }
+}
+
+module.exports = requestListenerHelper

package/src/model/Payload.js

@@ -0,0 +1,45 @@
+class Payload {
+    /**
+     * Create a miniapp payload.
+     * @param {string} workspaceUrl
+     * @param {string} shareId 
+     * @param {string} shareEnvironment
+     */
+    constructor(shareId, shareEnvironment){
+        this.shareId = shareId
+        this.shareEnvironment = shareEnvironment
+    }
+
+    /**
+     * @param {string} shareId
+     */
+    setShareId(shareId) {
+        this.shareId = shareId
+    }
+
+    /**
+   * Get shareId.
+   * @return {string}
+   */
+    getShareId() {
+        return this.shareId
+    }
+
+    /**
+     * @param {string} shareEnvironment
+     */
+    setShareEnvironment(shareEnvironment) {
+        this.shareEnvironment = shareEnvironment
+    }
+
+
+    /**
+ * Get shareEnvironment.
+ * @return {string}
+ */
+    getShareEnvironment() {
+        return this.shareEnvironment
+    }
+}
+
+module.exports = Payload

package/src/model/Target.js

@@ -0,0 +1,76 @@
+/* eslint-disable no-unused-vars */
+class TargetConfig {
+    constructor() {
+        this.id = ''
+        this.libUrl = ''
+        this.runnerUrl = ''
+        this.bootstrapBaseUrl = ''
+        this.askUserDataApiUrl = ''
+        this.default = ''
+    }
+}
+
+class MiniAppBoilerplateList {
+    constructor() {
+        this.name = ''
+        this.boilerplateUrl = ''
+        this.description = ''
+    }
+}
+
+module.exports = class Target {
+    constructor() {
+        /**
+        * @type {number}
+        */
+        this.id= ''
+        /**
+        * @type {string}
+        */
+        this.name= ''
+        /**
+        * @type {string}
+        */
+        this.minimumCliVersion= ''
+        /**
+        * @type {string}
+        */
+        this.boilerplateUrl= ''
+        /**
+        * @type {string}
+        */
+        this.superAppClientLibName= ''
+        /**
+        * @type {string}
+        */
+        this.componentsLibName= ''
+        /**
+        * @type {string}
+        */
+        this.description= ''
+        /**
+        * @type {boolean}
+        */
+        this.status= false
+        /**
+        * @type {string}
+        */
+        this.platform= ''
+        /**
+        *  @type {TargetConfig[]}
+        */
+        this.targetConfig= ''
+        /**
+        * @type {string}
+        */
+        this.sdkSupport= ''
+        /**
+        * @type {string}
+        */
+        this.default= ''
+        /**
+        *  @type {MiniAppBoilerplateList[]}
+        */
+        this.miniAppBoilerplateList= ''
+    }
+}

package/src/model/User.js

@@ -0,0 +1,11 @@
+class User {
+    constructor(name, email, roleid = 3, redefinepwd = false, password = '') {
+        this.name = name
+        this.email = email
+        this.roleid = roleid
+        this.redefinepwd = redefinepwd
+        this.password = password
+    }
+}
+
+module.exports = User

package/src/service/AuthConfig.js

@@ -0,0 +1,88 @@
+const fs = require('fs')
+const os = require('os')
+const path = require('path')
+const axios = require('axios')
+const config = require('config')
+const { exit } = require('process')
+
+const DEFAULT_ENV = 'hml'
+
+class AuthConfig { // abastract
+
+    constructor() {
+        this.blindGuardianUrl = config.get('blindGuardian').url
+    }
+
+    getConfPath() {}
+
+    readConf() {}
+
+    readClientCredentials() {
+        const credencialConfig = this.readConf()
+        let data
+        if (this._isOldProfileVersion(credencialConfig)) {
+            data = {
+                client_id: credencialConfig.devUser,
+                client_secret: credencialConfig.devKey,
+                grant_type: 'client_credentials'
+            }
+        }
+        else {
+            const env = process.env.NODE_ENV || DEFAULT_ENV
+            try {
+                data = {
+                    client_id: credencialConfig[env].devUser,
+                    client_secret: credencialConfig[env].devKey,
+                    grant_type: 'client_credentials'
+                }
+            }
+            catch (e) {
+
+                const errorMessage = `Configurações do ambiente (NODE_ENV=${env}) não definidas`
+                if(process.env.LOG_LEVEL === 'full') {
+                    console.error(errorMessage, e)
+                } else {
+                    console.error(errorMessage)
+                }
+
+                exit(1)
+            }
+        }
+
+        return data
+    }
+
+    async getToken() {
+        if(this.token)
+            return this.token
+
+        const clientCredentials = this.readClientCredentials()
+        try {
+            const url = `${this.blindGuardianUrl}/v1/o/auth`
+            const options = {
+                headers : {
+                    'User-Agent': config.get('userAgent')
+                }
+            }
+            const auth = await axios.post(url, clientCredentials, options)
+            this.token = auth.data
+            return this.token
+        } catch (e) {
+            if (this.verbose) {
+                console.log(e)
+            }
+            if (e.isAxiosError) {
+                if (e.response && e.response.status === 403) {
+                    throw new Error('Credencial inválida')
+                }
+                throw new Error('Por favor tente novamente mais tarde.')
+            }
+        }
+    }
+
+    _isOldProfileVersion(credentialConfig) {
+        return (credentialConfig.devKey || credentialConfig.devUser) ? true : false
+    }
+}
+
+module.exports = AuthConfig

package/src/service/BlindGuardian.js

@@ -0,0 +1,134 @@
+const fs = require('fs')
+const os = require('os')
+const path = require('path')
+const axios = require('axios')
+const config = require('config')
+const { exit } = require('process')
+const AmeCredential = require('../util/UserLocalCredential')
+const UserLocalCredential = require('../util/UserLocalCredential')
+
+const DEFAULT_ENV = 'hml'
+
+class BlindGuardian {
+    constructor() {
+        this.blindGuardianUrl = config.get('blindGuardian').url
+    }
+
+    /**
+     * @deprecated Use UserLocalCredential._getConfigPath
+     */
+    getConfPath() {
+        let configPath = path.resolve(
+            os.homedir(),
+            config.get('signup').get('configFilePath')
+        )
+
+        return configPath
+    }
+
+    readConf() {
+        const ameCredencial = new AmeCredential()
+        if (
+            process.env.AME_CLI_CLIENT_ID &&
+            process.env.AME_CLI_CLIENT_SECRET
+        ) {
+            return {
+                devUser: process.env.AME_CLI_CLIENT_ID,
+                devKey: process.env.AME_CLI_CLIENT_SECRET,
+            }
+        }
+        return new UserLocalCredential()._getNewConfigPath()
+    }
+
+    readClientCredentials() {
+        const credencialConfig = this.readConf()
+        let data
+        if (this._isOldProfileVersion(credencialConfig)) {
+            data = {
+                client_id: credencialConfig.devUser,
+                client_secret: credencialConfig.devKey,
+                grant_type: 'client_credentials',
+            }
+        } else {
+            const env = process.env.NODE_ENV || DEFAULT_ENV
+            try {
+                data = {
+                    client_id: credencialConfig[env].devUser,
+                    client_secret: credencialConfig[env].devKey,
+                    grant_type: 'client_credentials',
+                }
+            } catch (e) {
+                const errorMessage = `Configurações do ambiente (NODE_ENV=${env}) não definidas`
+                if (process.env.LOG_LEVEL === 'full') {
+                    console.error(errorMessage, e)
+                } else {
+                    console.error(errorMessage)
+                }
+
+                exit(1)
+            }
+        }
+
+        return data
+    }
+
+    async getToken() {
+        if (this.token) return this.token
+
+        const clientCredentials = this.readClientCredentials()
+        try {
+            const url = `${this.blindGuardianUrl}/v1/o/auth`
+            const options = {
+                headers: {
+                    'User-Agent': config.get('userAgent'),
+                },
+            }
+            const auth = await axios.post(url, clientCredentials, options)
+            this.token = auth.data
+            return this.token
+        } catch (e) {
+            if (this.verbose) {
+                console.log(e)
+            }
+            if (e.isAxiosError) {
+                if (e.response && e.response.status === 403) {
+                    throw new Error('Credencial inválida')
+                }
+                throw new Error('Por favor tente novamente mais tarde.')
+            }
+        }
+    }
+
+
+    async createUser(userVo) {
+        try {
+            const url = `${this.blindGuardianUrl}/v1/o/users`
+            const options = {
+                headers: {
+                    'User-Agent': config.get('userAgent'),
+                },
+            }
+            const auth = await axios.post(url, userVo, options)
+            return auth.data
+        } catch (e) {
+            if (process.env.LOG_LEVEL) {
+                console.log(e)
+            }
+            if (e.isAxiosError) {
+                if (e.response && e.response.status === 403) {
+                    throw new Error('Credencial inválida')
+                }
+                throw new Error('Por favor tente novamente mais tarde.')
+            }
+        }
+    }
+
+
+    _isOldProfileVersion(credentialConfig) {
+        return credentialConfig.devKey || credentialConfig.devUser
+            ? true
+            : false
+    }
+}
+
+module.exports = BlindGuardian

package/src/service/CliLogin.js

@@ -0,0 +1,47 @@
+const TrackingEitriAnalytics = require('./TrackingEitriAnalytics')
+const UserLocalCredential = require('../util/UserLocalCredential')
+
+class CliLogin {
+
+    async saveCredentials({email, credential}) {
+
+        let devUser = "", devKey = ""
+
+        try {
+            const developerKeyDecodec = atob(credential || "")
+            const developerKeyParsed = JSON.parse(developerKeyDecodec)
+
+            if (!developerKeyParsed?.clientId || !developerKeyParsed?.clientSecret) {
+                throw new Error("invalid_credential_format")
+            }
+
+            devUser = developerKeyParsed?.clientId
+            devKey = developerKeyParsed?.clientSecret
+        } catch (error) {
+            console.error("\n", "Não foi possível realizar o seu login. Por favor, verique as credenciais.")
+            TrackingEitriAnalytics.sendEvent({
+                command: "login",
+                success: false,
+                errorMessage: error?.message
+            })
+            process.exit(1)
+        }
+
+        console.log("\n", "Eis que a jornada tem início...")
+
+        await new UserLocalCredential().asyncSaveContent({devUser, devKey})
+        TrackingEitriAnalytics.sendEvent({
+            command: "login",
+            success: true,
+            data: {
+                email,
+                devUser
+            }
+        })
+        console.log("\n", `✔  Triunfo! O acesso foi concedido! Você está logado como ${email}.`)
+        process.exit(0)
+    }
+
+}
+
+module.exports = CliLogin

package/src/service/ConfigService.js

@@ -0,0 +1,16 @@
+const config = require('config')
+const {workspace} = require('../service/Workspace')
+
+class ConfigService {
+    constructor() {
+        this.configuration = config
+        if(workspace.isRollout()) {
+            this.configuration = require(`../../config/${process.env.NODE_ENV}`)
+            this.configuration.get = (key) => {
+                return this.configuration[key]
+            }
+        }
+    }
+}
+
+module.exports = new ConfigService().configuration

package/src/service/CredentialsService.js

@@ -0,0 +1,47 @@
+const config = require('config')
+
+class CredentialsService {
+
+    constructor(workspace) {
+        this.workspace = workspace
+        this.conf = config.get('workspace')
+    }
+
+    async upsert(args) {
+        const credential = args.credential
+
+        if (!credential) {
+            throw new Error('Nao foram fornecidas credenciais.')
+        }
+        if (!credential.clientId) {
+            throw new Error('Nao foi fornecido client_id')
+        }
+        if (!credential.clientSecret) {
+            throw new Error('Nao foi fornecido client_secret')
+        }
+
+        credential.grantType = this.conf.credentials.defaultGrantType
+
+        let publicKey = this.workspace.getMiniConf()['public-key']
+        let ultimatePath = this.conf.credentials.upsertUrlPath.replace(':publicKey', publicKey)
+        let url = `${this.conf.url}/${ultimatePath}`
+
+        await this.workspace.http.put(url, credential)
+    }
+
+    async createApproval(args) {
+        const approver = args.generate
+
+        if (!approver) {
+            throw new Error('Nao foi fornecido aprovador')
+        }
+
+        let publicKey = this.workspace.getMiniConf()['public-key']
+        let ultimatePath = this.conf.credentials.approvalUrlPath
+        let url = `${this.conf.url}/${ultimatePath}`
+        await this.workspace.http.post(url, { approver, publicKey })
+    }
+
+}
+
+module.exports = CredentialsService

package/src/service/GATrackingStrategy.js

@@ -0,0 +1,16 @@
+const { workspace } = require('./Workspace')
+
+const mobile =  workspace.getKnownAvailableTargets()[0].code
+
+const setMobileLibs2GA = (miniConf) => {
+    return {
+        superClientVersion: miniConf['eitri-app-client'],
+        componentsVersion: miniConf['eitri-app-components']
+    }
+}
+
+const MINIAPP_TARGET = {
+    [mobile]: setMobileLibs2GA
+}
+
+module.exports = MINIAPP_TARGET

package/src/service/HashFolder.js

@@ -0,0 +1,79 @@
+const fs = require('fs')
+const path = require('path')
+const {hashElement} = require('folder-hash')
+
+class HashFolder {
+    async calculate() {
+        const options = {
+            folders: {exclude: ['.*', 'node_modules', 'test_coverage']},
+            files: {
+                include: [
+                    '*.js',
+                    '*.jsx',
+                    '*.json',
+                    '*.svg',
+                    '*.png',
+                    '*.jpg',
+                    '*.jpeg',
+                    '*.gif',
+                    '*.txt',
+                ],
+            },
+        }
+        // let start = new Date().getTime();
+        const result = await hashElement(path.join(process.cwd(), 'src'), options)
+        // console.log(`${new Date().getTime() - start}ms`);
+        return result
+    }
+
+    writeHashFile(oldContent, content) {
+        return new Promise((resolve, reject) => {
+            fs.writeFile(
+                path.join(process.cwd(), 'src/folder.hash'),
+                `${oldContent}\n${content}`,
+                (err) => {
+                    if (err) {
+                        console.log(err)
+                        return reject(err)
+                    }
+                    resolve()
+                },
+            )
+        })
+    }
+
+    readHashFile() {
+        return new Promise((resolve, reject) => {
+            const fileName = path.join(process.cwd(), 'src/folder.hash')
+            if (!fs.existsSync(fileName)) {
+                resolve(null)
+                return
+            }
+            fs.readFile(fileName, 'utf8', (err, data) => {
+                if (err) {
+                    reject(err)
+                    return
+                }
+                resolve(data)
+            })
+        })
+    }
+
+    async readCurrentHash() {
+        const current = await this.readHashFile()
+        if (!current) {
+            return null
+        }
+        return current.split('\n').pop()
+    }
+
+    async updateHashFile() {
+        const res = await this.calculate()
+        const current = await this.readCurrentHash()
+        if (current !== res['hash']) {
+            await this.writeHashFile(current, res['hash'])
+        }
+    }
+}
+
+module.exports = HashFolder