eitri-cli 1.3.0-beta.2 → 1.3.0-beta.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eitri-cli",
-  "version": "1.3.0-beta.2",
+  "version": "1.3.0-beta.4",
   "description": "Command Line Interface to make \"Eitri-App\" with code and fire.",
   "main": "index.js",
   "bin": {

package/src/cmd/push-version.js

@@ -86,22 +86,14 @@ ${await targetService.getAppConfExampleSnippet()}
         const userWorkspace = await getWorkspace()
         await miniLog.connect(userWorkspace.id)
         console.log(separator)
-        console.log('Analisando versões')
+        console.log("Analisando versões...");
 
-        // Verificar se precisamos dessa parte
-        const {target} = await workspace.checkVersions()
-        // const {addedPermissions, removedPermissions} = await workspace.comparePermissions(target)
-        // await logPermissionsAndOpenPrompt(addedPermissions, removedPermissions, cmdObj)
-        // console.log(separator)
+        const { target } = await workspace.checkVersions();
 
-        console.log('Preparando os arquivos do seu Eitri-App')
-
-        await workspace.uploadAll()
-        const webhooks = workspace.getWebhooks()
-        printAvailableWebhooks(webhooks)
-        console.log('')
-        console.log(separator)
-        console.log('Gerando Eitri-App')
+        console.log("\nPreparando os arquivos do seu Eitri-App...");
+        await workspace.uploadZip();
+        console.log(separator);
+        console.log("Gerando versão do Eitri-App");
 
         const start = Date.now()
         let pushVersionPromise = miniLog.awaitForPushVersion()

package/src/cmd/start.js

@@ -74,14 +74,17 @@ module.exports = async function start(args) {
         const userWorkspace = await getWorkspace()
         await miniLog.connect(userWorkspace.id, silentOnConnect)
 
-        if (args.unzip) {
-            await workspace.uploadAll(args)
-        } else {
-            await workspace.uploadZip(args)
-        }
+        console.log("Construindo...");
+        await workspace.uploadZip(args);
+        console.log("Pronto!");
+
         const loadedTarget = await workspace.getTarget()
         const platform = loadedTarget.platform
-        await handleStartServer(args, trackingService, watcher, workspace, target, targetConfig, platform)
+        const argsWithDeeplinks = {
+            ...args,
+            deepLinks: loadedTarget?.deepLinks || []
+        }
+        await handleStartServer(argsWithDeeplinks, trackingService, watcher, workspace, target, targetConfig, platform)
 
         TrackingEitriAnalytics.sendEvent({
             eventName:"start",

package/src/service/StarterService.js

@@ -24,7 +24,7 @@ async function handleStartServer(args, trackingService, watcher, workspace, fact
     }
 
 
-    const starter = factory.create(args, trackingService, watcher, workspace, targetConfig)
+    const starter = await factory.create(args, trackingService, watcher, workspace, targetConfig)
     await starter.startServer()
 }
 

package/src/service/Workspace.js

@@ -475,14 +475,7 @@ class Workspace {
         return !isValidFileName;
     }
 
-    async upsert(filesPath, opts = {}, showProgressBar = false) {
-        if (showProgressBar) {
-            return await this.upsertConcurrency(
-                filesPath,
-                opts,
-                showProgressBar
-            );
-        }
+    async upsert(filesPath, opts = {}) {
         return await this.upsertSequencial(filesPath, opts);
     }
 
@@ -512,54 +505,6 @@ class Workspace {
         return holder.promise;
     }
 
-    async upsertConcurrency(filesPath, opts = {}, showProgressBar = false) {
-        const promises = [];
-        const isSaving = opts.why === WatcherOpts.SAVE;
-        if (showProgressBar) {
-            this.createProgressBar(showProgressBar);
-            this.progressBar.start(filesPath.length, 0);
-            this.progressBar.update(this.progressBarCounter);
-        }
-
-        for (const filePath of filesPath) {
-            const fileName = path.basename(filePath);
-
-            const { isInvalid, promise } = await this.validateFileName(
-                fileName,
-                filePath
-            );
-            if (isInvalid) return await promise;
-
-            const upsertFile = {
-                filePath,
-                opts,
-                requestNumber: this.requestNumber++,
-            };
-            promises.push(
-                this.execUpsertConcurrency(
-                    upsertFile,
-                    isSaving,
-                    showProgressBar
-                )
-            );
-        }
-
-        const promisesChunks = this.spliceArray(promises, 5);
-        const data = [];
-        for (const promiseArray of promisesChunks) {
-            const result = await Promise.all(promiseArray);
-            data.push(...result);
-        }
-
-        if (isSaving) return data[0];
-
-        if (showProgressBar) {
-            this.progressBar.update(filesPath.length);
-            this.progressBar.stop();
-        }
-        return data;
-    }
-
     async postFile(filePath, isSaving, opts) {
         const start = new Date().getTime();
         const relativePath = this.getRelativePath(filePath);
@@ -584,29 +529,6 @@ class Workspace {
             fileName,
         };
     }
-
-    async execUpsertConcurrency(upsertFile, isSaving, showProgressBar = false) {
-        const { filePath, opts, requestNumber } = upsertFile;
-
-        const { fileName, relativePath, start } = await this.postFile(
-            filePath,
-            isSaving,
-            opts
-        );
-
-        if (showProgressBar) {
-            this.progressBarCounter++;
-            this.progressBar.update(this.progressBarCounter);
-        }
-        return {
-            filePath,
-            relativePath,
-            requestNumber,
-            time: new Date().getTime() - start,
-            baseName: fileName,
-        };
-    }
-
     async execUpsertSequencial(isSaving) {
         this.uploading = true;
         for (let i = 0; i < this.upsertQueue.length; i++) {
@@ -792,37 +714,6 @@ class Workspace {
         return allFiles;
     }
 
-    async uploadAll() {
-        await this.mkdirs([this.folder2watch, ...this.resourceFolders2watch]);
-        await this.rmAllServerFiles();
-        await this.hashFolder.updateHashFile();
-
-        const srcFiles = await this.listFilesInCorrectOrder();
-        const filesfromSrc = srcFiles.filter((f) => !f.endsWith("folder.hash"));
-        const srcFolderHash = srcFiles.filter((f) => f.endsWith("folder.hash"));
-
-        const resourceFiles = await this.getAllResourceFiles(
-            this.resourceFolders2watch
-        );
-
-        let files = resourceFiles.concat(filesfromSrc);
-        const componentFiles = files.filter((file) =>
-            file.includes("/components")
-        );
-
-        const opts = {
-            why: "save",
-            log: false,
-            skipCompile: true,
-        };
-        const showProgressBar = true;
-        if (componentFiles && componentFiles.length > 0) {
-            await this.preUpsert(componentFiles, opts);
-        }
-        await this.upsert(files, opts, showProgressBar);
-        await this.transpile(srcFolderHash);
-    }
-
     async preUpsert(componentsFiles, opts) {
         for (const filePath of componentsFiles) {
             await this.upsertSequencial(filePath, opts);
@@ -869,8 +760,6 @@ class Workspace {
         );
         admZip.addLocalFolder("./src");
 
-        console.log("Construindo");
-
         const platform = process.platform;
 
         const zipPath = await this.resolveOs(platform);
@@ -878,8 +767,6 @@ class Workspace {
         await this.sendZip(zipPath);
 
         await this.transpile(folderHash);
-
-        console.log("Pronto");
     }
 
     async resolveOs(platform) {
@@ -1156,37 +1043,6 @@ class Workspace {
     toBase64(content) {
         return Buffer.from(content).toString("base64");
     }
-
-    createProgressBar(showProgressBar) {
-        if (showProgressBar) {
-            this.progressBar = new cliProgress.SingleBar(
-                {
-                    format: "Sincronizando [{bar}] {percentage}% | ETA: {eta}s | {value}/{total} Arquivos sincronizados...",
-                },
-                cliProgress.Presets.shades_classic
-            );
-        }
-    }
-
-    /**
-     *
-     * @param {unknown[]} array
-     * @param {number} chunkCount
-     * @returns {unknown[][]}
-     */
-    spliceArray(array, chunkCount) {
-        var chunks = [],
-            iterator,
-            auxiliar;
-        for (
-            iterator = 0, auxiliar = array.length;
-            iterator < auxiliar;
-            iterator += chunkCount
-        ) {
-            chunks.push(array.slice(iterator, iterator + chunkCount));
-        }
-        return chunks;
-    }
 }
 
 module.exports = {

package/src/service/factories/QRCodeStarterFactory.js

@@ -3,6 +3,7 @@ const { Ios, Android } = require("uri-scheme");
 const readline = require("readline");
 const chalk = require("chalk");
 const os = require("os");
+
 function QRCodeStarter(
     args,
     trackingService,
@@ -56,35 +57,51 @@ function QRCodeStarter(
         _QRCodeFactory.generate({ ...this.args, qrCodePath, fullUrl });
 
         if (this.args.emulator) {
-            tryOpenEmulator(fullUrl, args);
+            await tryOpenEmulator(fullUrl, args);
         }
 
-        listenerKeyPressToOpenEmulator(fullUrl);
+        await listenerKeyPressToOpenEmulator(fullUrl, args.deepLinks);
     };
 }
 
-function tryOpenEmulator(fullUrl, args) {
+async function tryOpenEmulator(fullUrl, args) {
     const shareId = extractShareId(fullUrl);
-    const { emulator } = args;
-    if (emulator === "ios") {
-        return Ios.openAsync({ uri: `eitri://workspace/${shareId}` }).catch(
-            () => {
-                console.error(
-                    `Houve um erro ao tentar abrir o Eitri-App na plataforma iOS`
-                );
+    const { emulator, deepLinks } = args;
+    if(!deepLinks || deepLinks?.length < 1) {
+        console.log("Seu application não contém deep links configurados.")
+        return
+    };
+    
+    let opened = false
+    for await (const deepLink of deepLinks) {
+        if(opened) return
+        try {
+            if (emulator === "ios") {
+                Ios.openAsync({ uri: `${deepLink}/${shareId}` })
+                    .then(() => {opened = true})
+                    .catch(() => {
+                        opened = false; 
+                        console.log(`Houve um erro ao tentar abrir o Eitri-App na plataforma iOS`)
+                    })
+            } else {
+                Android.openAsync({ uri: `${deepLink}/${shareId}` })
+                    .then(() => {opened = true})
+                    .catch(() => {
+                        opened = false; 
+                        console.log(`Houve um erro ao tentar abrir o Eitri-App na plataforma Android`)
+                    })
             }
-        );
-    }
-    return Android.openAsync({ uri: `eitri://workspace/${shareId}` }).catch(
-        () => {
+        } catch (error) {
             console.error(
-                `Houve um erro ao tentar abrir o Eitri-App na plataforma Android`
+                `Houve um erro ao tentar abrir o Eitri-App na plataforma ${emulator}`
             );
         }
-    );
+    }
+
 }
 
-function listenerKeyPressToOpenEmulator(url) {
+async function listenerKeyPressToOpenEmulator(url, deepLinks) {
+    if(!deepLinks || deepLinks?.length < 1) return;
     const enterText = chalk.blue.bold("Enter");
     console.log("================================================");
     console.log(`\t${chalk.green.bold("Abertura de Eitri-App automática")}`);
@@ -104,20 +121,16 @@ function listenerKeyPressToOpenEmulator(url) {
     console.log("================================================");
     readline.emitKeypressEvents(process.stdin);
 
-    process.stdin.on("keypress", (chunk, key) => {
+    process.stdin.on("keypress", async (chunk, key) => {
         if (key && key.name == "a") {
             const emulator = "android";
             console.log(`Abrindo Eitri-App no ${chalk.blue.bold("Android")}`);
-            tryOpenEmulator(url, { emulator });
+            await tryOpenEmulator(url, { emulator, deepLinks });
         }
         if (os.platform() === "darwin" && key && key.name == "i") {
             const emulator = "ios";
             console.log(`Abrindo Eitri-App no ${chalk.blue.bold("iOS")}`);
-            tryOpenEmulator(url, { emulator });
-        }
-        if (key && key.name == "q") {
-            console.log("Parando execução do Eitri-App");
-            process.exit(0);
+            await tryOpenEmulator(url, { emulator, deepLinks });
         }
     });
 }

package/test/e2e/cli.test.js

@@ -7,6 +7,8 @@ const minutes = 60000;
 const Executor = require("../Executor.js");
 const Helper = require("../Helper.js");
 const ConfigService = require("../../src/service/ConfigService.js");
+const Http = require("../../src/service/Http.js");
+const BlindGuardian = require("../../src/service/BlindGuardian.js");
 
 describe("eitri-cli", () => {
     const EITRI_WORK_DIR = path.join(__dirname, "..", "..", "developer-folder");
@@ -137,6 +139,67 @@ describe("eitri-cli", () => {
         }
     });
 
+    it(
+        "should do push-version",
+        async () => {
+            const EITRI_APP_NAME = `eitri-test-${Date.now()}`;
+            try {
+                await execAsync(
+                    `cd ${EITRI_WORK_DIR} && rm -rf ./eitri-test-*`,
+                    { env: process.env }
+                );
+
+                const executor = new Executor({ env: devEnv });
+                await executor
+                    .exec(
+                        `cd ${EITRI_WORK_DIR} && eitri create ${EITRI_APP_NAME} --yes --application=APPLICATION_CALINDRA`,
+                        { env: devEnv }
+                    )
+                    .waitFor(/Download de template completo/);
+                await new Promise((resolve) => setTimeout(resolve, 200));
+                const EITRI_APP_FOLDER = path.resolve(
+                    EITRI_WORK_DIR,
+                    EITRI_APP_NAME
+                );
+                const startExecution = new Executor({ env: devEnv });
+                await startExecution
+                    .exec(`cd ${EITRI_APP_FOLDER} && eitri start`)
+                    .waitFor(/Utilize o QR-Code para iniciar o seu Eitri-App/);
+                executor.child.kill();
+                startExecution.child.kill();
+
+                const pushVersion = new Executor({ env: devEnv });
+                await pushVersion
+                    .exec(`cd ${EITRI_APP_FOLDER} && eitri push-version`)
+                    .waitFor(/disponível no Eitri Console/);
+                pushVersion.child.kill();
+
+                const conf = require(`../../developer-folder/${EITRI_APP_NAME}/eitri-app.conf.js`);
+                const data = await getPublishedVersion(conf.version, conf.id);
+
+                expect(data.length).toBe(1);
+                expect(data[0].version).toBe(conf.version);
+                expect(data[0].eitriAppId).toBe(conf.id);
+
+                await Helper.delete(conf.id);
+            } catch (e) {
+                console.error(e);
+                throw e;
+            }
+        },
+        2 * minutes
+    );
+
+    const getPublishedVersion = async (version, eitriAppId) => {
+        const blindGuardian = new BlindGuardian();
+        const http = new Http(blindGuardian);
+
+        const url = `https://api.eitri.tech/eitri-manager-api/revisions?eitriAppId=${eitriAppId}&version=${version}`;
+
+        const data = await http.get(url);
+        return data;
+    };
+
     const sleep = (timeInMs) => {
         return new Promise((resolve) => setTimeout(resolve, timeInMs));
     };