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

package/src/service/Http.js

@@ -1,300 +0,0 @@
-const axiosCookieJarSupport = require("axios-cookiejar-support").wrapper
-const FileCookieStore = require("tough-cookie-file-store").FileCookieStore
-const CookieJar = require("tough-cookie").CookieJar
-
-const os = require("os")
-const path = require("path")
-const getCliVersion = require("../util/getCliVersion")
-const { randomUUID } = require("crypto")
-const getWorkspace = require("../util/getWorkspace")
-
-const filePath = path.join(os.homedir(), "./.eitri.cookie.json")
-const jar = new CookieJar(new FileCookieStore(filePath))
-const axios = axiosCookieJarSupport(require("axios").create({ withCredentials: true, jar }))
-const debug = require("debug")("eitri:http")
-
-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
-        this.workspaceId = ""
-    }
-
-    setTokenFactory(tokenFactory) {
-        this.tokenFactory = tokenFactory
-    }
-
-    setToken(token) {
-        this.token = token
-    }
-
-    setWorkspaceId(id) {
-        this.workspaceId = id
-    }
-
-    getCookieSession(url) {
-        return new Promise((resolve, reject) => {
-            const contextPath = process.env.FOUNDRY_CONTEXT_PATH || "foundry"
-            jar.getCookies(url, { allPaths: true }, function (err, cookies) {
-                if (err) return reject(err)
-                const cookie = cookies.find((c) => c.path === `/${contextPath}`)
-                resolve(cookie)
-            })
-        })
-    }
-
-    async post(url, data, headers) {
-        try {
-            if (!this.token) {
-                this.token = await this.tokenFactory.getToken()
-            }
-            const mergedHeaders = {
-                ...(await this._getHeader(url)),
-                ...headers,
-            }
-            return await axios.post(url, data, { headers: mergedHeaders })
-        } catch (e) {
-            debug(`Error: url ${url}`)
-            throw e
-        }
-    }
-
-    async postForm(url, formData, additionalHeaders = {}) {
-        if (!this.token) {
-            this.token = await this.tokenFactory.getToken()
-        }
-
-        const headers = {
-            ...(await this._getHeader(url)),
-            "Content-Type": `multipart/form-data; boundary=${formData.getBoundary()}`,
-            ...additionalHeaders,
-        }
-        return await this._postForm(url, formData, headers)
-    }
-
-    async _getHeader(url) {
-        const tid = randomUUID()
-        const headers = {
-            Authorization: `Bearer ${this.token.accessToken}`,
-            "X-Transaction-Id": tid,
-            "App-Tools-Version": getCliVersion(),
-        }
-        if (url.includes("foundry") || url.includes("runes-foundry")) {
-            headers["Workspace-Id"] = this.workspaceId ? this.workspaceId : (await getWorkspace()).id
-        }
-
-        return headers
-    }
-
-    __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, additionalHeaders = {}) {
-        if (!this.token) {
-            this.token = await this.tokenFactory.getToken()
-        }
-        const headers = {
-            ...(await this._getHeader(url)),
-            ...additionalHeaders,
-        }
-        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 = await this._getHeader(url)
-        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(args.url)
-                                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 = { ...(await this._getHeader(url)), ...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
-    }
-
-    static printLeanLogAxiosError(e) {
-        const axios = require("axios")
-        if (axios.isAxiosError(e)) {
-            console.log(
-                `AxiosError: ${JSON.stringify(
-                    {
-                        status: e.status,
-                        config: {
-                            headers: e.config?.headers,
-                            method: e.config?.method,
-                            url: e.config?.url,
-                            data: Http.parseJson(e.config?.data),
-                        },
-                        responseData: e.response?.data,
-                    },
-                    null,
-                    4,
-                )}`,
-            )
-        } else {
-            console.log(e)
-        }
-    }
-    static parseJson(data) {
-        try {
-            return JSON.parse(data ?? "{}")
-        } catch (e) {
-            return {}
-        }
-    }
-}
-
-module.exports = Http

package/src/service/HuginService.js

@@ -1,38 +0,0 @@
-const BlindGuardian = require("./BlindGuardian");
-const Http = require("./Http");
-const configService = require("./ConfigService");
-const VegvisirService = require("../modules/vegvisir/VegvisirService");
-const FormData = require("form-data");
-const fs = require('fs')
-
-module.exports = class HuginService {
-  constructor() {
-    this.config = configService.get("workspace");
-    this.blindGuardian = new BlindGuardian();
-    this.http = new Http(this.blindGuardian);
-    this.vegvisirService = new VegvisirService()
-
-  }
-
-  async postServerless(data, eitriConf) {
-    const { filePath, relativePath, isDevMode } = data
-    const formData = new FormData();
-    const workspace = await this.vegvisirService.getWorkspace();
-    formData.append("file", fs.createReadStream(filePath));
-    formData.append("organizationId", eitriConf.organizationId);
-    formData.append("version", eitriConf.version);
-    formData.append("filepath", relativePath);
-    formData.append("isDevMode", String(isDevMode));
-    formData.append("eitriAppId", eitriConf.id);
-    formData.append("applicationId", eitriConf.applicationId);
-    formData.append("workspaceId", workspace.id);
-    let url = this.getServerlessUploadUrl(filePath);
-    await this.http.postForm(url, formData);
-  }
-
-  getServerlessUploadUrl(filePath) {
-    if (filePath.includes(".zip"))
-      return `${this.config.hugin.url}${this.config.hugin.uploadZip}`;
-    return `${this.config.hugin.url}${this.config.hugin.uploadFile}`;
-  }
-}

package/src/service/InviteService.js

@@ -1,45 +0,0 @@
-const configService = require('./ConfigService')
-
-class InviteService {
-
-    constructor(workspace) {
-        this.workspace = workspace
-        this.conf = configService.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/LibsService.js

@@ -1,191 +0,0 @@
-const axios = require("axios")
-const configService = require("./ConfigService")
-const CDN_83io_LIBRARY = configService.get("cdn")?.library
-const TrackingEitriAnalytics = require("./TrackingEitriAnalytics")
-const { validateUUID } = require("../util/GenericUtils")
-
-class LibsService {
-    static async validateLibsVersions({ libs = [], eitriAppConf = {} }) {
-        const libsList = libs
-
-        if (eitriAppConf["eitri-commons"]) {
-            libsList.push({
-                name: "eitri-commons",
-                version: eitriAppConf["eitri-commons"],
-            })
-        }
-
-        const { luminusUiVersion, bifrostVersion, commonsVersion } = this.getEitriConfLibsVersions(libsList)
-
-        if (commonsVersion) {
-            const validCommonsVersion = await this.validCommonsVersion(commonsVersion)
-            if (!validCommonsVersion) {
-                throw new Error(`A versão [${commonsVersion}] do [eitri-commons] definida em seu eitri-app.conf é inválida.`)
-            }
-        }
-
-        if (!luminusUiVersion) {
-            throw new Error("Nenhuma versão do [luminus-ui/eitri-app-components] encontrada em seu eitri-app.conf")
-        }
-
-        if (!bifrostVersion) {
-            throw new Error("Nenhuma versão do [bifrost/eitri-app-client] encontrada em seu eitri-app.conf")
-        }
-
-        const { luminusUiVersions, bifrostVersions } = await this.simultaneousRequestAndHandleData()
-        const allBifrostVersions = bifrostVersions?.versions?.concat(
-            bifrostVersions?.betaVersions,
-            bifrostVersions?.alphaVersions,
-        )
-
-        if (!luminusUiVersion.includes("@") && !validateUUID(luminusUiVersion)) {
-            const existsLuminus = luminusUiVersions?.versions?.some((version) => version === luminusUiVersion)
-            if (!existsLuminus) {
-                this.throwNonExistentLibError({
-                    libName: "luminus-ui/eitri-app-components",
-                    eitriConfLibVersion: luminusUiVersion,
-                    availableVersions: luminusUiVersions,
-                    eitriAppConf,
-                })
-            }
-        }
-
-        if (!bifrostVersion.includes("@")) {
-            const existsBifrost = allBifrostVersions.some((version) => version === bifrostVersion)
-            if (!existsBifrost) {
-                this.throwNonExistentLibError({
-                    libName: "bifrost/eitri-app-client",
-                    eitriConfLibVersion: bifrostVersion,
-                    availableVersions: allBifrostVersions,
-                    eitriAppConf,
-                })
-            }
-        }
-    }
-
-    static async validCommonsVersion(commonsVersion) {
-        try {
-            const fullUrl = `${CDN_83io_LIBRARY.url}${CDN_83io_LIBRARY.commons.versions}`
-            const response = await axios.get(fullUrl)
-            const data = response.data;
-            return data.versions.includes(commonsVersion)
-        } catch (error) {
-            const errorMessage = error?.message || "Erro na obtenção de versões do Bifrost"
-            this.sendErrorToAnalytics("getBifrostVersions", errorMessage)
-        }
-
-        return false
-    }
-
-    static getEitriConfLibsVersions(libs = []) {
-        const luminusUiNames = ["eitri-app-components", "eitri-luminus"]
-        const biFrostNames = ["eitri-app-client", "eitri-bifrost"]
-        const commonsNames = ["eitri-commons"]
-        const bifrostVersion = libs.find((lib) => biFrostNames?.includes(lib.name))?.version
-        const luminusUiVersion = libs.find((lib) => luminusUiNames?.includes(lib.name))?.version
-        const commonsVersion = libs.find((lib) => commonsNames?.includes(lib.name))?.version
-
-        return {
-            luminusUiVersion,
-            bifrostVersion,
-            commonsVersion,
-        }
-    }
-
-    static async simultaneousRequestAndHandleData() {
-        const promises = await Promise.allSettled([this.getBifrostVersions(), this.getLuminusUiVersions()])
-            .then((res) => res)
-            .catch((err) => err)
-
-        const [bifrost, luminus] = promises
-
-        let allBifrostVersions = {}
-        if (bifrost?.status === "fulfilled") {
-            allBifrostVersions = bifrost.value
-        }
-
-        let allLuminusVersions = {}
-        if (luminus?.status === "fulfilled") {
-            allLuminusVersions = luminus.value
-        }
-
-        return {
-            luminusUiVersions: allLuminusVersions,
-            bifrostVersions: allBifrostVersions,
-        }
-    }
-
-    static handleRawDatas(promises = []) {
-        const [bifrost, luminus] = promises
-
-        const allBifrostVersions = []
-        if (bifrost?.status === "fulfilled") {
-            const versions = bifrost?.value?.versions?.concat(bifrost?.value?.betaVersions, bifrost?.value?.alphaVersions)
-            allBifrostVersions.push(...versions)
-        }
-
-        const allLuminusVersions = []
-        if (luminus?.status === "fulfilled") {
-            allLuminusVersions.push(...luminus.value.versions)
-        }
-
-        return {
-            luminusUiVersions: allLuminusVersions,
-            bifrostVersions: allBifrostVersions,
-        }
-    }
-
-    static async getBifrostVersions() {
-        const fullUrl = `${CDN_83io_LIBRARY.url}${CDN_83io_LIBRARY.bifrost.versions}`
-        try {
-            const response = await axios.get(fullUrl)
-            return response.data
-        } catch (error) {
-            const errorMessage = error?.message || "Erro na obtenção de versões do Bifrost"
-            this.sendErrorToAnalytics("getBifrostVersions", errorMessage)
-        }
-    }
-
-    static async getLuminusUiVersions() {
-        const fullUrl = `${CDN_83io_LIBRARY.url}${CDN_83io_LIBRARY.luminusUi.versions}`
-        try {
-            const response = await axios.get(fullUrl)
-            return response.data
-        } catch (error) {
-            const errorMessage = error?.message || "Erro na obtenção de versões do LuminusUI"
-            this.sendErrorToAnalytics("getLuminusUiVersions", errorMessage)
-        }
-    }
-
-    static sendErrorToAnalytics(method = "", errorMessage = "") {
-        TrackingEitriAnalytics.sendEvent({
-            eventName: `${method}.error`,
-            userId: "",
-            data: { errorMessage },
-        })
-    }
-
-    static throwNonExistentLibError(input = { libName: "", eitriConfLibVersion: "", availableVersions: [], eitriAppConf: {} }) {
-        const { libName, eitriConfLibVersion, availableVersions, eitriAppConf } = input
-
-        const friendlyErrorMessage = `Versão da biblioteca [${libName}] não encontrada`
-        console.log(`\n\x1b[1m\x1b[31m${friendlyErrorMessage}\x1b[0m\n`)
-        console.log("Veja as versões disponíveis abaixo e atualize o arquivo eitri-app.conf\n")
-        console.log(availableVersions)
-
-        TrackingEitriAnalytics.sendEvent({
-            eventName: "version.eitri-libs.not.found",
-            userId: "",
-            data: {
-                errorMessage: `Versão da biblioteca ${libName} não encontrada`,
-                eitriConfLibVersion,
-                availableVersions,
-                eitriAppConf,
-            },
-        })
-
-        process.exit(1)
-    }
-}
-
-module.exports = LibsService

package/src/service/ManageEnvService.js

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