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

package/src/service/Workspace.js

@@ -1,1045 +0,0 @@
-const fs = require("fs")
-const os = require("os")
-const path = require("path")
-const Http = require("./Http")
-const Base64 = require("base-64")
-const TagTree = require("./TagTree")
-const FormData = require("form-data")
-const { v4: uuidv4 } = require("uuid")
-const AdmZip = require("adm-zip")
-const BlindGuardian = require("./BlindGuardian")
-const HashFolder = require("./HashFolder")
-const packageJson = require(path.resolve(__dirname, "..", "..", "package.json"))
-const tempFolderPath = require("../util/os").OS_MAPPER
-const TargetService = require("../service/TargetService")
-const WatcherOpts = require("../enum/WatcherOpts")
-const ipv4 = require("../util/ipv4")
-const { compressToBase64 } = require("lz-string")
-const Buffer = require("buffer")
-const DEFAULT_ENV = "dev"
-const cliProgress = require("cli-progress")
-const EitriAppManager = require("./EitriAppManager")
-const EitriAppService = require("./EitriAppService")
-const HuginService = require("./HuginService")
-const EitriAppType = require("../model/EitriAppType")
-const LibsService = require("./LibsService")
-const { LogSuccess } = require("../util/LogUtil")
-const { extractSlug } = require("../util/LibUtil")
-const huginService = new HuginService()
-const YAML = require("yaml")
-const { readFile } = require("fs/promises")
-const convertKeysToCamelCase = require("../util/convertKeysToCamelCase")
-const { exit } = require("process")
-const debug = require("debug")("eitri:Workspace")
-const FileUtils = require("../util/FileUtils")
-
-class Workspace {
-    constructor(blindGuardian, hashFolder) {
-        const configService = require("./ConfigService")
-        this.config = configService.get("workspace")
-        this.basePath = this.config.basePath
-        this.blindGuardian = blindGuardian
-        this.hashFolder = hashFolder
-        this.folder2watch = ""
-        this.resourceFolders2watch = []
-        this.http = new Http(this.blindGuardian)
-        this.upsertQueue = []
-        this.requestNumber = 0
-        this.publishing = false
-        if (!this.config.hugin) {
-            console.warn("Missing colossus config inside workspace.")
-        }
-        this.shareApi = configService.get("shareApi")
-        this.vegvisir = configService.get("vegvisir")
-        this.targets = []
-
-        /**
-         * @type {cliProgress.SingleBar}
-         * @private
-         */
-        this.progressBar
-        this.progressBarCounter = 0
-        /**
-         * @type {EitriAppService}
-         * @private
-         */
-        this.eitriAppService = new EitriAppService()
-    }
-
-    getTargets() {
-        return this.targets
-    }
-
-    setTargets(targets) {
-        this.targets = targets
-    }
-
-    setServerUrl(url) {
-        this.serverUrl = url
-    }
-
-    setQrCodeUrl(qrCodeUrl) {
-        this.qrCodeUrl = qrCodeUrl
-    }
-
-    setFolder2Watch(folderPath) {
-        this.folder2watch = folderPath
-    }
-
-    setResourceFolder2Watch(resourceFolders2watch) {
-        this.resourceFolders2watch = resourceFolders2watch
-    }
-
-    getResourceFolder2Watch() {
-        return this.resourceFolders2watch
-    }
-
-    getTarget() {
-        if (!this.target) {
-            console.warn("Target não foi detectado no setup()")
-        }
-
-        return this.target
-    }
-
-    async getProjectSourceFolderSize() {
-        return await FileUtils.getFolderSize(this.folder2watch)
-    }
-
-    async init() {
-        const token = await this.blindGuardian.getToken()
-        this.http.setToken(token)
-        this.userEmail = token.email
-    }
-
-    async initPushVersion(workspaceId = "") {
-        this.http.setWorkspaceId(workspaceId)
-        this.init()
-    }
-
-    getMiniConf() {
-        if (!this._miniConf) {
-            const eitriAppConfPath = path.resolve(this.folder2watch, "../eitri-app.conf.js")
-            if (fs.existsSync(eitriAppConfPath)) {
-                this._miniConf = require(eitriAppConfPath)
-            } else {
-                const miniAppConfPath = path.resolve(this.folder2watch, "../miniapp.conf.js")
-                if (!fs.existsSync(miniAppConfPath)) {
-                    throw new Error("Por favor, verifique se você está dentro da pasta de um projeto Eitri-App.")
-                }
-                this._miniConf = require(miniAppConfPath)
-            }
-            if (!this._miniConf.version) {
-                throw Error("Arquivo eitri-app.conf.js sem version")
-            }
-        }
-        if (process.env.WORKSPACE_SHARED) {
-            this._miniConf["eitri-luminus"] = process.env.WORKSPACE_SHARED
-        }
-        return this._miniConf
-    }
-
-    setMiniConf(miniConf) {
-        this._miniConf = miniConf
-        return new Promise((resolve, reject) => {
-            const eitriAppConfPath = path.resolve(this.folder2watch, "../eitri-app.conf.js")
-            if (fs.existsSync(eitriAppConfPath)) {
-                const jsonContent = JSON.stringify(miniConf, null, 4)
-                fs.writeFile(eitriAppConfPath, `module.exports = ${jsonContent}`, (err) => {
-                    if (err) {
-                        console.log(err)
-                        return reject(err)
-                    }
-                    resolve()
-                })
-            } else {
-                const miniAppConfPath = path.resolve(this.folder2watch, "../miniapp.conf.js")
-                const jsonContent = JSON.stringify(miniConf, null, 4)
-                fs.writeFile(miniAppConfPath, `module.exports = ${jsonContent}`, (err) => {
-                    if (err) {
-                        console.log(err)
-                        return reject(err)
-                    }
-                    resolve()
-                })
-            }
-        })
-    }
-
-    async setup(args) {
-        const eitriConf = this.getMiniConf()
-        eitriConf.isShared = args?.shared
-        const headers = {
-            accept: this.config.libs.updateLibsEndpointVersion,
-        }
-
-        let runAppMode = "CLIENT_APP"
-        if (args?.playground) runAppMode = "PLAYGROUND"
-
-        debug("RUN_APP_MODE", runAppMode)
-
-        try {
-            const appConfig = await this.getAppConfig()
-            const setupResponse = await this.http.post(
-                `${this.serverUrl}/${this.basePath}/v2/workspace/setup`,
-                {
-                    eitriConf,
-                    appConfig,
-                    runAppMode,
-                },
-                headers,
-            ) // somente para garantir que a pasta do usuario existe
-
-            console.log("Preparando compilador")
-            await this.http.put(`${this.serverUrl}/${this.basePath}/version`, eitriConf, headers) // TODO PDV Setup fara isso aqui
-            console.log("Compilador pronto para uso contínuo")
-
-            const setupData = setupResponse.data
-
-            const { state, application, eitriConf: remoteEitriConf } = setupData
-
-            if (!application) {
-                console.error("O Aplicativo não foi encontrado durante o processo de setup do Eitri-App.")
-                return exit(1)
-            }
-
-            if (!this.eitriAppService.validEitriConf(eitriConf)) {
-                await this.eitriAppService.writeEitriConf(remoteEitriConf, eitriConf, this.folder2watch)
-            }
-
-            await LibsService.validateLibsVersions({ libs: state.libs, eitriAppConf: eitriConf })
-
-            this.printLibsVersion(state)
-
-            await this.loadTarget(application)
-
-            return setupData
-        } catch (e) {
-            if (e.response && e.response.data && e.response.data.name === "WorkspaceService.setup.mismatchAppType") {
-                console.error(`\x1b[1m\x1b[31m${e.response.data.message}\x1b[0m`)
-                process.exit(1)
-            }
-            throw Error(e)
-        }
-    }
-
-    async getAppConfig() {
-        const appConfigPath = path.resolve(this.folder2watch, "../../app-config.yaml")
-        if (!fs.existsSync(appConfigPath)) return
-        const content = await readFile(appConfigPath, "utf8")
-        const appConfig = YAML.parse(content)
-        return convertKeysToCamelCase(appConfig)
-    }
-
-    async loadTarget(remoteTarget) {
-        const targets = await this.availableTargets()
-        this.target = targets.find((t) => t.name === remoteTarget.name)
-
-        if (!this.target) {
-            const friendlyErrorMessage = `Você ainda não foi registrado na application [${remoteTarget?.name}]. Por favor, entre em contato com o administrador da sua organização.`
-            throw new Error(friendlyErrorMessage)
-        }
-    }
-
-    printLibsVersion(state) {
-        const miniConf = this.getMiniConf()
-        let libVersionsOutput = ""
-        state.libs.forEach((lib) => {
-            let libraryDisplayName = lib.name
-            if (libraryDisplayName === "eitri-luminus") {
-                libraryDisplayName = extractSlug(miniConf[lib.name])
-            }
-
-            let version = miniConf[lib.name]
-            if (version) {
-                // Captura a versao da lib quando estamos usando uma url
-                // "https://eitri.s3.amazonaws.com/eitri-app-client-0.8.0-alpha.tgz".match(/(\d+\.\d+\.\d+([-a-z]*))/)
-                const m = version.match(/(\d+\.\d+\.\d+([-a-z]*))/)
-                if (m) {
-                    version = m[1]
-                }
-                libVersionsOutput += `      ${libraryDisplayName} [${version}]`
-            }
-        })
-        console.log(" ", libVersionsOutput, "\n")
-    }
-
-    async checkVersions() {
-        try {
-            const eitriConf = this.getMiniConf()
-            const headers = {
-                accept: this.config.libs.updateLibsEndpointVersion,
-            }
-
-            // somente para garantir que a pasta do usuario existe
-            LogSuccess("1/8 ✓ Preparando ambiente de desenvolvimento")
-            await this.http.post(`${this.serverUrl}/${this.basePath}/v2/workspace/setup`, { eitriConf }, headers)
-            
-            LogSuccess("2/8 ✓ Verificando permissões de publicação")
-            const response = await this.http.put(
-                `${this.serverUrl}/${this.basePath}/version?command=push-version`,
-                eitriConf,
-                headers,
-            )
-
-            LogSuccess("3/8 ✓ Ambiente de desenvolvimento preparado")
-
-            eitriConf.target = response.application
-            const availableTargets = await this.availableTargets()
-            let libs = TargetService.getLibsFromMiniConf(eitriConf, availableTargets)
-            LogSuccess("4/8 ✓ Ambiente pronto para compilação.")
-
-            const eitriConfProperties = Object.getOwnPropertyNames(eitriConf)
-            const clientName =
-                eitriConfProperties.find((p) => p === libs.bifrost) || TargetService.LIBS_FOR_TARGET.MOBILE_NEW.bifrost
-            const componentsName =
-                eitriConfProperties.find((p) => p === libs.luminus) || TargetService.LIBS_FOR_TARGET.MOBILE_NEW.luminus
-
-            const bifrostVersion = eitriConf[clientName]
-            const luminusVersion = eitriConf[componentsName]
-
-            LogSuccess(
-                `5/8 ✓ Criando versão com as bibliotecas: ${clientName} [${bifrostVersion}] | ${componentsName} [${luminusVersion}]`,
-            )
-            return { target: response.target }
-        } catch (error) {
-            const errorMessage = this.handleErrorMessage(error)
-            console.log(`\n\x1b[1m\x1b[31m${errorMessage}\x1b[0m`)
-            process.exit(1)
-        }
-    }
-
-    handleErrorMessage(error) {
-        let errorMessage = error.message
-        if (error.response && error.response.data && error.response.data.message) {
-            errorMessage = error.response.data.message
-        }
-        return errorMessage
-    }
-
-    isDiff(miniConf, onlineVersion, packageName) {
-        return miniConf[packageName] && onlineVersion[packageName] !== miniConf[packageName]
-    }
-
-    async getWorkspaceConnectionData(args, serverUrl) {
-        const cookie = await this.http.getCookieSession(serverUrl)
-        const miniConf = this.getMiniConf()
-        const viewHtml = args.view || "index"
-        let environment = process.env.NODE_ENV || DEFAULT_ENV
-        if (environment === "prod") environment = "prd"
-        let miniAppData = {
-            developerEmail: this.userEmail,
-            environment: environment,
-            albCookie: cookie.cookieString(),
-            orderId: args.orderId,
-            shareId: args.shareId,
-            slug: miniConf.slug,
-            publicKey: miniConf["public-key"] || miniConf.publicKey,
-            view: viewHtml,
-        }
-        // delete miniAppData.albCookie
-        return Base64.encode(JSON.stringify(miniAppData))
-    }
-
-    /**
-     *
-     * @param {string} bootstrapBaseUrl
-     */
-    getBootstrapURL(bootstrapBaseUrl) {
-        const LOCALHOST = "http://localhost:"
-        if (bootstrapBaseUrl.startsWith(LOCALHOST) && process.env.NODE_ENV === "loc") {
-            const HOST = ipv4()[0]
-            const PORT = bootstrapBaseUrl.split(LOCALHOST)[1]
-            return `http://${HOST}:${PORT}`
-        }
-        return bootstrapBaseUrl
-    }
-
-    async getNewWorkspaceURL(args, setupConfig, eitriAppConf) {
-        const qrCodeConfig = await this.getQrCodeConfig(args, setupConfig)
-        const stateData = await this.saveShareState(qrCodeConfig, eitriAppConf)
-        const stateId = stateData.id
-        const miniAppUrl = `${this.qrCodeUrl}/${stateId}`
-        return {
-            miniAppConf: {
-                ...qrCodeConfig,
-                shareId: stateId,
-            },
-            miniAppUrl,
-        }
-    }
-
-    async saveShareState(qrCodeConfig, eitriAppConf) {
-        const createWorkspaceStateUrl = `${this.serverUrl}/${this.basePath}/share`
-        const requestBody = {
-            id: uuidv4(),
-            state: {
-                ...qrCodeConfig,
-                eitriAppId: eitriAppConf?.id || "",
-                organizationId: eitriAppConf?.organizationId || "",
-                applicationId: eitriAppConf?.applicationId || "",
-            },
-        }
-        const response = await this.http.post(createWorkspaceStateUrl, requestBody)
-        return response.data
-    }
-
-    async getQrCodeConfig(args, setupConfig) {
-        args = args || {}
-        const cookie = await this.http.getCookieSession(this.serverUrl)
-        let cid
-        const miniAppConf = this.getMiniConf()
-        const view = (args.view || "index") + ".html"
-        const initializationParams = args.initializationParams
-        const orderId = args.orderId
-
-        if (cookie) {
-            cid = Base64.encode(cookie.cookieString())
-        }
-
-        const config = {
-            developerEmail: this.userEmail,
-            publicKey: miniAppConf["public-key"],
-            metadata: miniAppConf["metadata"],
-            slug: miniAppConf["slug"],
-            title: miniAppConf["title"],
-            permissions: miniAppConf["permissions"],
-            miniAppBootstrapUrl: this.getBootstrapURL(setupConfig.eitriAppBootstrapURL),
-            developmentDeeplink: setupConfig.developmentDeeplink,
-            initializationParams,
-            orderId,
-            view,
-            extras: {
-                cid, // superapp joga tudo do extras na query string do bootstrapUrl .... Pq ja nao mandamos na queryString ja daqui?
-            },
-        }
-
-        if (process.env.APP_START_WORKSPACE_CONFIG) {
-            const startAppsConfig = await this.getEitriStartAppsWorkspacesConfig()
-            if (startAppsConfig) {
-                config.focusedEitriApp = startAppsConfig.focusedEitriApp
-                config.applicationId = startAppsConfig.applicationId
-                config.environmentId = startAppsConfig.environmentId
-                config.devEnvKey = startAppsConfig.devEnvKey
-                config.workspaces = startAppsConfig.workspaces
-            }
-        }
-
-        return config
-    }
-
-    async getEitriStartAppsWorkspacesConfig() {
-        try {
-            const appConfig = await this.getAppConfig()
-            const url = `${this.vegvisir.url}${this.vegvisir.basePath}${this.vegvisir.my}`
-            const responseWorkspaces = await this.http.get(url)
-
-            const workspaces = []
-            let focusedEitriApp = ""
-            let workspaceFocused = ""
-
-            for (const eitriApp of appConfig.eitriApps) {
-                const eitriAppPath = eitriApp.path
-
-                const eitriAppConfPath = path.resolve(process.cwd(), "..", eitriAppPath, "eitri-app.conf.js")
-
-                if (fs.existsSync(eitriAppConfPath)) {
-                    const eitriAppContent = require(eitriAppConfPath)
-                    const workspaceRemoteInfo = responseWorkspaces.find((rw) => rw.name === eitriApp.workspace)
-
-                    if (eitriApp.focus) {
-                        focusedEitriApp = eitriAppContent.slug
-                        workspaceFocused = workspaceRemoteInfo.id
-                    }
-
-                    const foundryContextPath = process.env.FOUNDRY_CONTEXT_PATH || "foundry"
-                    const workspaceUrl = `https://api.eitri.tech/${foundryContextPath}/user/${workspaceRemoteInfo.id}/index.html`
-
-                    workspaces.push({
-                        name: eitriApp?.workspace,
-                        id: workspaceRemoteInfo?.id,
-                        url: workspaceUrl,
-                        slug: eitriAppContent?.slug,
-                        eitriAppId: eitriAppContent?.id,
-                    })
-                } else {
-                    console.error(`Eitri-App Conf não encontrado: ${eitriAppConfPath}`)
-                }
-            }
-
-            const fakerDevEnvKey = `dev-${new Date().getTime()}-${workspaceFocused}`
-            return {
-                focusedEitriApp,
-                applicationId: appConfig?.applicationId,
-                environmentId: appConfig?.environmentId,
-                devEnvKey: fakerDevEnvKey,
-                workspaces,
-            }
-        } catch (error) {
-            console.error("Erro ao obter configurações do Workspaces: ", error?.message)
-        }
-    }
-
-    getRelativePath(filePath) {
-        return filePath
-            .replace(this.folder2watch, "")
-            .replace(this.folder2watch.replace(/\\/g, "/"), "")
-            .replace(process.cwd(), "")
-    }
-
-    async delete(filePath) {
-        const relPath = this.getRelativePath(filePath)
-        const url = `${this.serverUrl}/${this.basePath}/fileupload`
-        const params = {
-            filepath: relPath,
-        }
-        const projectSize = await this.getProjectSourceFolderSize()
-        await this.http.delete(
-            url,
-            {
-                params,
-            },
-            {
-                "project-size": projectSize,
-            },
-        )
-    }
-
-    hasAccent(fileName) {
-        const fileRegex = /[À-ź]/g
-        const isValidFileName = !fileRegex.test(fileName)
-        return !isValidFileName
-    }
-
-    async upsert(filesPath, opts = {}) {
-        return await this.upsertSequencial(filesPath, opts)
-    }
-
-    async upsertSequencial(filePath, opts = {}) {
-        const fileName = path.basename(filePath)
-
-        const { isInvalid, promise } = await this.validateFileName(fileName, filePath)
-        if (isInvalid) return await promise
-
-        const holder = this.createPromiseHolder()
-        this.upsertQueue.push({
-            filePath,
-            opts,
-            holder,
-            requestNumber: this.requestNumber++,
-        })
-
-        const isDevMode = opts.why === WatcherOpts.SAVE
-
-        if (!this.uploading) {
-            await this.execUpsertSequencial(isDevMode)
-        }
-
-        return holder.promise
-    }
-
-    async postFile(filePath, isDevMode, opts) {
-        const start = new Date().getTime()
-        const relativePath = this.getRelativePath(filePath)
-        const fileName = path.basename(filePath)
-        if (relativePath.startsWith(this.config.hugin.watchUserDir)) {
-            const data = {
-                filePath,
-                relativePath: relativePath.replace(this.config.hugin.watchUserDir, ""),
-                isDevMode,
-            }
-            await huginService.postServerless(data, this.getMiniConf())
-        } else {
-            await this.postFormData(filePath, relativePath, opts)
-        }
-        return {
-            start,
-            relativePath,
-            fileName,
-        }
-    }
-    async execUpsertSequencial(isDevMode) {
-        this.uploading = true
-        for (let i = 0; i < this.upsertQueue.length; i++) {
-            const { filePath, opts, holder, requestNumber } = this.upsertQueue[i]
-
-            try {
-                const { relativePath, start } = await this.postFile(filePath, isDevMode, opts)
-
-                holder.resolve({
-                    filePath,
-                    relativePath,
-                    requestNumber,
-                    time: new Date().getTime() - start,
-                })
-            } catch (e) {
-                holder.reject(e)
-                break // na duvida se deve abortar a fila toda
-            }
-        }
-        this.upsertQueue = []
-        this.uploading = false
-    }
-
-    async validateFileName(fileName, filePath) {
-        const hasAccent = this.hasAccent(fileName)
-        let promise
-        if (hasAccent) {
-            const message = ` - No nome do arquivo possui um ou mais caracteres não permitidos: ${fileName}`
-            console.log(message)
-
-            promise = Promise.resolve({
-                filePath,
-                relativePath: this.getRelativePath(filePath),
-                time: 0,
-                requestNumber: this.requestNumber++,
-                message,
-            })
-        }
-        return {
-            isInvalid: hasAccent,
-            promise,
-        }
-    }
-
-    createPromiseHolder() {
-        const holder = {}
-        holder.promise = new Promise((resolve, reject) => {
-            holder.resolve = resolve
-            holder.reject = reject
-        })
-        return holder
-    }
-
-    async postFormData(filePath, relativePath, opts) {
-        let conf = this.getMiniConf()
-        const formData = new FormData()
-        formData.append("filepath", relativePath)
-        formData.append("why", opts.why || "")
-        formData.append("file", fs.createReadStream(filePath))
-        formData.append("miniAppVersion", conf.version)
-        if (opts.forceTranspile) {
-            formData.append("forceTranspile", opts.forceTranspile)
-        }
-        const url = `${this.serverUrl}/${this.basePath}/fileupload`
-        const projectSize = await this.getProjectSourceFolderSize()
-        return await this.http.postForm(url, formData, {
-            "project-size": projectSize,
-        })
-    }
-
-    getEnvCode() {
-        if (!this.publishing) {
-            return "ws"
-        }
-        if (["dev", "loc"].includes(process.env.NODE_ENV)) {
-            return "dev"
-        } else {
-            return "hml"
-        }
-    }
-
-    async isSynchronized() {
-        const res = await Promise.all([
-            this.hashFolder.calculate(),
-            this.http.get(`${this.serverUrl}/${this.basePath}/fileupload`),
-        ])
-        const folderHashValue = res[0]["hash"]
-        const serverHash = res[1]["hash"]
-        return folderHashValue === serverHash
-    }
-
-    async rmAllServerFiles() {
-        await this.delete("/")
-    }
-
-    async listFilesInCorrectOrder() {
-        const allFiles = await this.walk(this.folder2watch)
-        const componentsPath = path.join(this.folder2watch, "components")
-        const componentTagRegExp = new RegExp(`${componentsPath}/[^/]+.jsx`)
-        const filesWithoutComponentTags = allFiles.filter((fileName) => {
-            return !fileName.match(componentTagRegExp)
-        })
-        let files = filesWithoutComponentTags.sort((a, b) => {
-            if (a.includes("components") && !b.includes("components")) return -1
-            if (!a.includes("components") && b.includes("components")) return 1
-            if (a.includes("folder.hash")) return 1
-            if (b.includes("folder.hash")) return -1
-            return 0
-        })
-        const tagsFiles = await new TagTree().tagsFilesSorted(componentsPath)
-        files = tagsFiles.map((fileName) => path.join(componentsPath, fileName)).concat(files)
-        return files
-    }
-
-    async getAllResourceFiles(resources) {
-        let allFiles = []
-        resources.forEach(async (dir) => {
-            const files = await this.walk(dir)
-            allFiles.push(...files)
-        })
-        return allFiles
-    }
-
-    async preUpsert(componentsFiles, opts) {
-        for (const filePath of componentsFiles) {
-            await this.upsertSequencial(filePath, opts)
-        }
-    }
-
-    async uploadZip(isDevMode) {
-        const admZip = new AdmZip()
-        await this.mkdirs([this.folder2watch, ...this.resourceFolders2watch])
-        await this.rmAllServerFiles()
-        await this.hashFolder.updateHashFile()
-        const allFiles = await this.listFilesInCorrectOrder()
-        const files = allFiles.filter((f) => !f.endsWith("folder.hash"))
-        const folderHash = allFiles.filter((f) => f.endsWith("folder.hash"))
-
-        const hasServerless = files.find((file) => file.includes(this.config.hugin.watchUserDir))
-        if (hasServerless) {
-            const serverlessFolderPath = path.join(this.folder2watch, this.config.hugin.watchUserDir)
-
-            const serverlessZip = new AdmZip()
-            serverlessZip.addLocalFolder(serverlessFolderPath, undefined, (fileName) => fileName.includes("."))
-            const now = Date.now()
-            const tempZip = path.join(os.tmpdir(), `eitri-serverless-${now}.zip`)
-            await serverlessZip.writeZipPromise(tempZip, { overwrite: true, perm: 777 })
-
-            const data = {
-                filePath: tempZip,
-                // No upload do Zip é ignorado
-                relativePath: tempZip,
-                isDevMode,
-            }
-            await huginService.postServerless(data, this.getMiniConf())
-        }
-
-        admZip.addFile("__files_order.txt", allFiles.map((f) => f.split(this.folder2watch)[1].replace(/\\/g, "/")).join("\n"))
-        admZip.addLocalFolder("./src")
-
-        const platform = process.platform
-
-        const zipPath = await this.resolveOs(platform)
-        admZip.writeZip(zipPath)
-        await this.sendZip(zipPath)
-
-        await this.transpile(folderHash)
-    }
-
-    async uploadCleanZip(isDevMode) {
-        const admZip = new AdmZip()
-        await this.mkdirs([this.folder2watch, ...this.resourceFolders2watch])
-        await this.rmAllServerFiles()
-        await this.hashFolder.updateHashFile()
-        const allFiles = await this.listFilesInCorrectOrder()
-        const filesWithoutTestJSAndTestTS = allFiles.filter((file) => !file.endsWith(".test.js") && !file.endsWith(".test.ts"))
-        const files = filesWithoutTestJSAndTestTS.filter((f) => !f.endsWith("folder.hash"))
-        const folderHash = filesWithoutTestJSAndTestTS.filter((f) => f.endsWith("folder.hash"))
-
-        const hasServerless = files.find((file) => file.includes(this.config.hugin.watchUserDir))
-        if (hasServerless) {
-            const serverlessFolderPath = path.join(this.folder2watch, this.config.hugin.watchUserDir)
-
-            const serverlessZip = new AdmZip()
-            serverlessZip.addLocalFolder(serverlessFolderPath, undefined, (fileName) => fileName.includes("."))
-            const now = Date.now()
-            const tempZip = path.join(os.tmpdir(), `eitri-serverless-${now}.zip`)
-            await serverlessZip.writeZipPromise(tempZip, { overwrite: true, perm: 777 })
-
-            const data = {
-                filePath: tempZip,
-                // No upload do Zip é ignorado
-                relativePath: tempZip,
-                isDevMode,
-            }
-            await huginService.postServerless(data, this.getMiniConf())
-        }
-
-        admZip.addFile(
-            "__files_order.txt",
-            filesWithoutTestJSAndTestTS.map((f) => f.split(this.folder2watch)[1].replace(/\\/g, "/")).join("\n"),
-        )
-        admZip.addLocalFolder("./src")
-
-        const platform = process.platform
-
-        const zipPath = await this.resolveOs(platform)
-        admZip.writeZip(zipPath)
-        await this.sendZip(zipPath)
-
-        await this.transpile(folderHash)
-    }
-
-    async resolveOs(platform) {
-        let tempDir = ""
-        if (tempFolderPath[platform]) {
-            tempDir = await tempFolderPath[platform]()
-        } else {
-            tempDir = "."
-        }
-        return tempDir + "/miniApp.zip"
-    }
-
-    async sendFiles(publishMessage) {
-        const miniConf = this.getMiniConf()
-        const formData = new FormData()
-
-        formData.append("miniAppName", miniConf.name || "sem nome")
-        formData.append("miniAppSlug", miniConf.slug || "sem-slug")
-        formData.append("miniAppTitle", miniConf.title || "Sem Titulo")
-        formData.append("miniAppVersion", miniConf.miniAppVersion || miniConf.version || "v1")
-        formData.append("organizationName", miniConf.organization.name)
-        formData.append("publishMessage", publishMessage || "")
-
-        const url = `${this.serverUrl}/${this.basePath}/publish?async=true`
-        const projectSize = await this.getProjectSourceFolderSize()
-        await this.http.postForm(url, formData, {
-            "project-size": projectSize,
-        })
-    }
-
-    async sendZip(zip) {
-        const formData = new FormData()
-        formData.append("file", fs.createReadStream(zip))
-        const url = `${this.serverUrl}/${this.basePath}/uploadAll`
-        const projectSize = await this.getProjectSourceFolderSize()
-        await this.http.postForm(url, formData, {
-            "project-size": projectSize,
-        })
-    }
-
-    async transpile(files) {
-        if (files.length > 0) {
-            return await this.upsert(...files, {
-                why: "uploadAll",
-                log: false,
-            })
-        }
-    }
-
-    mkdirs(dirnames) {
-        return new Promise((resolve, reject) => {
-            dirnames.forEach((dirname) => {
-                fs.mkdir(dirname, { recursive: true }, (err) => {
-                    if (err) {
-                        return reject(err)
-                    }
-                    resolve()
-                })
-            })
-        })
-    }
-
-    async getFileNames(dir) {
-        const folder = path.resolve(this.folder2watch, dir)
-        const fileList = await this.walk(folder)
-
-        const fileNames = fileList.map((filePath) => {
-            return path.basename(filePath)
-        })
-
-        return fileNames
-    }
-
-    async walk(dir) {
-        let results = []
-        const list = fs.readdirSync(dir)
-        for (let i = 0; i < list.length; i++) {
-            let file = list[i]
-            file = path.join(dir, file)
-            const stat = fs.statSync(file)
-            if (stat && stat.isDirectory()) {
-                /* Recurse into a subdirectory */
-                results = results.concat(await this.walk(file))
-            } else {
-                /* Is a file */
-                results.push(file)
-            }
-        }
-        return results
-    }
-
-    async pushVersionAsJson(args) {
-        let headers = {}
-        if (this.config.apiVersion && this.config.apiVersion.v2Header) {
-            headers = {
-                accept: this.config.apiVersion.v2Header,
-            }
-        }
-        const miniConf = this.getMiniConf()
-        const body = {
-            miniConf,
-            buildMessage: args.message,
-            cliVersion: packageJson.version,
-            eitriAppType: args.shared ? EitriAppType.SHARED : EitriAppType.APPLICATION,
-        }
-        const url = `${this.serverUrl}/${this.basePath}/publish?async=true`
-        await this.http.post(url, body, headers)
-    }
-
-    async create(conf) {
-        const url = `${this.serverUrl}/${this.basePath}/create`
-        return await this.http
-            .post(url, conf)
-            .then((res) => res.data)
-            .catch((err) => {
-                if (
-                    err.isAxiosError &&
-                    err.response &&
-                    err.response.status === 409 &&
-                    err.response.data &&
-                    err.response.data.error
-                ) {
-                    console.log("Error: " + err.response.data.error)
-                    let dupError = new Error(err.response.data.error)
-                    dupError.isDuplicatedError = true
-                    dupError.field = err.response.data.field
-                    throw dupError
-                }
-                console.log(err.message)
-                if (err && err.response) {
-                    console.log(err.response.data)
-                }
-                throw err
-            })
-    }
-
-    async applyRolloutEnvironmentIfNeeded() {
-        const start = Date.now()
-        try {
-            const { slug } = this.getMiniConf()
-            const url = `${this.serverUrl}/${this.basePath}/users/miniapps/${slug}/actions/WORKSPACE_ROLLOUT`
-            const response = await this.http.get(url)
-            if (response.result) {
-                process.env["NODE_ENV"] = "beta"
-                this.rollout = response.result
-
-                console.log("\n")
-                console.log("\t╔═══════════════════════════════════════╗")
-                console.log("\t║ Atenção: Utilizando Beta Workspace    ║")
-                console.log("\t╚═══════════════════════════════════════╝\n")
-            }
-        } catch (e) {
-            if (process.env.LOG_LEVEL === "full") {
-                console.log(e)
-            }
-        }
-
-        if (process.env.LOG_LEVEL === "full") {
-            console.log("Check rollout time", Date.now() - start)
-        }
-    }
-
-    isRollout() {
-        return this.rollout
-    }
-
-    // bff
-    async availableTargets() {
-        if (this.getTargets().length === 0) {
-            const targets = await new EitriAppManager(this.blindGuardian).findAllApplications()
-            this.setTargets(targets)
-            return targets
-        }
-        return this.getTargets()
-    }
-
-    // local
-    getKnownAvailableTargets() {
-        return this.config.target.knownTargets
-    }
-
-    async getDefaultTarget() {
-        await this.availableTargets()
-        return this.getTargets().find((value) => value.default)
-    }
-
-    // client http configurado conforme as necessidades do workspace
-    getHttp() {
-        return this.http
-    }
-
-    async comparePermissions(target) {
-        const miniConf = this.getMiniConf()
-        const permissions = miniConf.permissions || []
-        const permissionsWithTarget = permissions.map((permission) => ({
-            ...permission,
-            target,
-        }))
-        const slug = miniConf.slug
-        const { data } = await this.http.post(
-            `${this.serverUrl}/${this.basePath}/miniapps/${slug}/permissions/compare`,
-            permissionsWithTarget,
-        )
-        const addedPermissions = []
-        const removedPermissions = []
-        if (data.diffCount > 0) {
-            data.result.forEach((result) => {
-                if (result.status === "added") {
-                    addedPermissions.push(result.entity.permission)
-                } else {
-                    removedPermissions.push(result.entity.permission)
-                }
-            })
-        }
-        return { addedPermissions, removedPermissions }
-    }
-
-    async clean() {
-        await this.getHttp().delete(`${this.serverUrl}/${this.basePath}/sources`, {})
-    }
-
-    compressCode(code) {
-        const { SERVERLESS_CODE_COMPRESSION: compressionType, LOG_LEVEL } = process.env
-
-        let compressedCode,
-            codeLength = code.length
-        let maxPreviewLenth = 50
-        let previewLength = codeLength > maxPreviewLenth ? maxPreviewLenth : codeLength
-
-        if (compressionType === "base64") {
-            compressedCode = this.toBase64(code)
-
-            if (LOG_LEVEL === "full") {
-                console.log(
-                    `Enviando arquivo sem compactacao em base64: ${code.substring(0, previewLength)}, codeLenth: ${codeLength}`,
-                )
-            }
-        } else if (compressionType === "none") {
-            if (LOG_LEVEL === "full") {
-                console.log(
-                    `Enviando arquivo sem qualquer compressao: ${code.substring(0, previewLength)}, codeLenth: ${codeLength}`,
-                )
-            }
-        } else if (!compressionType || compressionType === "shrink") {
-            compressedCode = compressToBase64(code)
-
-            if (LOG_LEVEL === "full") {
-                console.log(
-                    `File preview: ${code.substring(0, previewLength)}, Before compression: ${codeLength}, After compression: ${compressedCode.length
-                    }`,
-                )
-            }
-        }
-
-        return {
-            code: compressedCode || code,
-            compressionType: compressionType || "shrink",
-        }
-    }
-
-    toBase64(content) {
-        return Buffer.from(content).toString("base64")
-    }
-
-    getFolderHashPath() {
-        const folderHashPath = path.join(this.folder2watch, "folder.hash")
-        return folderHashPath
-    }
-}
-
-module.exports = {
-    workspace: new Workspace(new BlindGuardian(), new HashFolder()),
-    Workspace,
-}