@hubspot/cli 4.2.0 → 4.2.1-beta.1

package/lib/LocalDevManager.js

@@ -11,7 +11,11 @@ const {
   logApiErrorInstance,
   ApiErrorContext,
 } = require('@hubspot/cli-lib/errorHandlers');
-const { ERROR_TYPES } = require('@hubspot/cli-lib/lib/constants');
+const {
+  PROJECT_BUILD_TEXT,
+  PROJECT_DEPLOY_TEXT,
+  ERROR_TYPES,
+} = require('@hubspot/cli-lib/lib/constants');
 const { isAllowedExtension } = require('@hubspot/cli-lib/path');
 const { shouldIgnoreFile } = require('@hubspot/cli-lib/ignoreRules');
 const {
@@ -53,26 +57,25 @@ class LocalDevManager {
     this.uploadPermission =
       options.uploadPermission || UPLOAD_PERMISSIONS.always;
     this.debug = options.debug || false;
+
     this.projectSourceDir = path.join(
       this.projectDir,
       this.projectConfig.srcDir
     );
-    this.spinnies = null;
     this.watcher = null;
     this.uploadQueue = null;
     this.standbyChanges = [];
     this.debouncedBuild = null;
     this.currentStagedBuildId = null;
-    this.port = options.port;
-    this.devServerPath = null;
 
     if (!this.targetAccountId || !this.projectConfig || !this.projectDir) {
+      logger.log(i18n(`${i18nKey}.failedToInitialize`));
       process.exit(EXIT_CODES.ERROR);
     }
   }
 
   async start() {
-    this.spinnies = SpinniesManager.init();
+    SpinniesManager.init();
 
     this.watcher = chokidar.watch(this.projectSourceDir, {
       ignoreInitial: true,
@@ -88,26 +91,32 @@ class LocalDevManager {
     }
 
     console.clear();
+    SpinniesManager.removeAll();
 
-    this.uploadQueue.start();
+    logger.log(i18n(`${i18nKey}.header.betaMessage`));
+    logger.log();
 
-    await this.startServers();
+    this.updateConsoleHeader();
 
-    this.logConsoleHeader();
+    await this.devServerStart();
+
+    this.uploadQueue.start();
     await this.startWatching();
+
     this.updateKeypressListeners();
+
+    this.updateConsoleHeader();
   }
 
   async stop() {
     this.clearConsoleContent();
 
-    this.spinnies.add('cleanupMessage', {
+    SpinniesManager.add('cleanupMessage', {
       text: i18n(`${i18nKey}.exitingStart`),
     });
 
     await this.stopWatching();
-
-    await this.cleanupServers();
+    await this.devServerCleanup();
 
     let exitCode = EXIT_CODES.SUCCESS;
 
@@ -133,11 +142,11 @@ class LocalDevManager {
     }
 
     if (exitCode === EXIT_CODES.SUCCESS) {
-      this.spinnies.succeed('cleanupMessage', {
+      SpinniesManager.succeed('cleanupMessage', {
         text: i18n(`${i18nKey}.exitingSucceed`),
       });
     } else {
-      this.spinnies.fail('cleanupMessage', {
+      SpinniesManager.fail('cleanupMessage', {
         text: i18n(`${i18nKey}.exitingFail`),
       });
     }
@@ -145,29 +154,8 @@ class LocalDevManager {
     process.exit(exitCode);
   }
 
-  logConsoleHeader() {
-    this.spinnies.removeAll();
-    this.spinnies.add('betaMessage', {
-      text: i18n(`${i18nKey}.header.betaMessage`),
-      category: 'header',
-      status: 'non-spinnable',
-    });
-
-    // this.spinnies.add('learnMoreLink', {
-    //   text: uiLink(
-    //     i18n(`${i18nKey}.header.learnMoreLink`),
-    //     this.generateLocalURL(`/hs/learnMore`),
-    //     { inSpinnies: true }
-    //   ),
-    //   category: 'header',
-    //   status: 'non-spinnable',
-    // });
-    this.spinnies.add('spacer-1', {
-      text: ' ',
-      status: 'non-spinnable',
-      category: 'header',
-    });
-    this.spinnies.add('devModeRunning', {
+  updateConsoleHeader() {
+    SpinniesManager.addOrUpdate('devModeRunning', {
       text: i18n(`${i18nKey}.header.running`, {
         accountIdentifier: uiAccountDescription(this.targetAccountId),
         projectName: this.projectConfig.name,
@@ -175,34 +163,41 @@ class LocalDevManager {
       isParent: true,
       category: 'header',
     });
-    this.spinnies.add('devModeStatus', {
+    SpinniesManager.addOrUpdate('devModeStatus', {
       text: i18n(`${i18nKey}.header.status.clean`),
       status: 'non-spinnable',
       indent: 1,
       category: 'header',
     });
-    this.spinnies.add('viewInHubSpotLink', {
-      text: uiLink(
-        i18n(`${i18nKey}.header.viewInHubSpotLink`),
-        this.generateLocalURL(`/hs/project`),
-        { inSpinnies: true }
-      ),
+
+    const viewText = DevServerManager.initialized
+      ? uiLink(
+          i18n(`${i18nKey}.header.viewInHubSpotLink`),
+          DevServerManager.generateURL(`hs/project`),
+          {
+            inSpinnies: true,
+          }
+        )
+      : ' ';
+
+    SpinniesManager.addOrUpdate('viewInHubSpotLink', {
+      text: viewText,
       status: 'non-spinnable',
       indent: 1,
       category: 'header',
     });
-    this.spinnies.add('spacer-2', {
+    SpinniesManager.addOrUpdate('spacer-1', {
       text: ' ',
       status: 'non-spinnable',
       category: 'header',
     });
-    this.spinnies.add('keypressMessage', {
+    SpinniesManager.addOrUpdate('quitHelper', {
       text: i18n(`${i18nKey}.header.quitHelper`),
       status: 'non-spinnable',
       indent: 1,
       category: 'header',
     });
-    this.spinnies.add('lineSeparator', {
+    SpinniesManager.addOrUpdate('lineSeparator', {
       text: '-'.repeat(50),
       status: 'non-spinnable',
       noIndent: true,
@@ -211,7 +206,7 @@ class LocalDevManager {
   }
 
   clearConsoleContent() {
-    this.spinnies.removeAll({ preserveCategory: 'header' });
+    SpinniesManager.removeAll({ preserveCategory: 'header' });
   }
 
   updateKeypressListeners() {
@@ -223,13 +218,13 @@ class LocalDevManager {
         this.uploadPermission === UPLOAD_PERMISSIONS.manual &&
         this.hasAnyUnsupportedStandbyChanges()
       ) {
-        this.spinnies.remove('manualUploadRequired');
-        this.spinnies.remove('manualUploadExplanation1');
-        this.spinnies.remove('manualUploadExplanation2');
-        this.spinnies.remove('manualUploadPrompt');
+        SpinniesManager.remove('manualUploadRequired');
+        SpinniesManager.remove('manualUploadExplanation1');
+        SpinniesManager.remove('manualUploadExplanation2');
+        SpinniesManager.remove('manualUploadPrompt');
 
         if (key.name === 'y') {
-          this.spinnies.add(null, {
+          SpinniesManager.add(null, {
             text: i18n(`${i18nKey}.upload.manualUploadConfirmed`),
             status: 'succeed',
             succeedColor: 'white',
@@ -237,10 +232,10 @@ class LocalDevManager {
           });
           this.updateDevModeStatus('manualUpload');
           await this.createNewStagingBuild();
-          await this.flushStandbyChanges();
+          this.flushStandbyChanges();
           await this.queueBuild();
         } else if (key.name === 'n') {
-          this.spinnies.add(null, {
+          SpinniesManager.add(null, {
             text: i18n(`${i18nKey}.upload.manualUploadSkipped`),
             status: 'fail',
             failColor: 'white',
@@ -251,12 +246,44 @@ class LocalDevManager {
     });
   }
 
-  generateLocalURL(path) {
-    return this.devServerPath ? `${this.devServerPath}${path}` : null;
+  logBuildError(buildStatus = {}) {
+    const subTasks = buildStatus[PROJECT_BUILD_TEXT.SUBTASK_KEY] || [];
+    const failedSubTasks = subTasks.filter(task => task.status === 'FAILURE');
+
+    if (failedSubTasks.length) {
+      this.updateDevModeStatus('buildError');
+
+      failedSubTasks.forEach(failedSubTask => {
+        SpinniesManager.add(null, {
+          text: failedSubTask.errorMessage,
+          status: 'fail',
+          failColor: 'white',
+          indent: 1,
+        });
+      });
+    }
+  }
+
+  logDeployError(deployStatus = {}) {
+    const subTasks = deployStatus[PROJECT_DEPLOY_TEXT.SUBTASK_KEY] || [];
+    const failedSubTasks = subTasks.filter(task => task.status === 'FAILURE');
+
+    if (failedSubTasks.length) {
+      this.updateDevModeStatus('deployError');
+
+      failedSubTasks.forEach(failedSubTask => {
+        SpinniesManager.add(null, {
+          text: failedSubTask.errorMessage,
+          status: 'fail',
+          failColor: 'white',
+          indent: 1,
+        });
+      });
+    }
   }
 
   updateDevModeStatus(langKey) {
-    this.spinnies.update('devModeStatus', {
+    SpinniesManager.update('devModeStatus', {
       text: i18n(`${i18nKey}.header.status.${langKey}`),
       status: 'non-spinnable',
       noIndent: true,
@@ -283,9 +310,12 @@ class LocalDevManager {
       logger.debug(err);
       if (isSpecifiedError(err, { subCategory: ERROR_TYPES.PROJECT_LOCKED })) {
         await cancelStagedBuild(this.targetAccountId, this.projectConfig.name);
-        logger.log(i18n(`${i18nKey}.previousStagingBuildCancelled`));
+        SpinniesManager.add(null, {
+          text: i18n(`${i18nKey}.previousStagingBuildCancelled`),
+          status: 'non-spinnable',
+        });
       }
-      process.exit(EXIT_CODES.ERROR);
+      this.stop();
     }
   }
 
@@ -315,13 +345,7 @@ class LocalDevManager {
       remotePath: path.relative(this.projectSourceDir, filePath),
     };
 
-    const notifyResponse = await this.notifyServers(changeInfo);
-
-    if (!notifyResponse.uploadRequired) {
-      this.updateDevModeStatus('supportedChange');
-      this.addChangeToStandbyQueue({ ...changeInfo, supported: true });
-
-      await this.executeServers(notifyResponse, changeInfo);
+    if (changeInfo.filePath.includes('dist')) {
       return;
     }
 
@@ -330,18 +354,10 @@ class LocalDevManager {
       return;
     }
 
-    if (this.uploadQueue.isPaused) {
-      this.addChangeToStandbyQueue({ ...changeInfo, supported: false });
-    } else {
-      await this.flushStandbyChanges();
-
-      if (!this.uploadQueue.isPaused) {
-        this.debounceQueueBuild(changeInfo);
-      }
+    this.addChangeToStandbyQueue({ ...changeInfo, supported: false });
 
-      return this.uploadQueue.add(async () => {
-        await this.sendChanges(changeInfo);
-      });
+    if (!this.uploadQueue.isPaused) {
+      this.flushStandbyChanges();
     }
   }
 
@@ -351,7 +367,7 @@ class LocalDevManager {
     if (this.uploadPermission === UPLOAD_PERMISSIONS.never) {
       this.updateDevModeStatus('noUploadsAllowed');
 
-      this.spinnies.add('noUploadsAllowed', {
+      SpinniesManager.add('noUploadsAllowed', {
         text: i18n(`${i18nKey}.upload.noUploadsAllowed`, {
           filePath: remotePath,
         }),
@@ -362,29 +378,34 @@ class LocalDevManager {
     } else {
       this.updateDevModeStatus('manualUploadRequired');
 
-      this.addChangeToStandbyQueue({ ...changeInfo, supported: false });
-
-      this.spinnies.add('manualUploadRequired', {
-        text: i18n(`${i18nKey}.upload.manualUploadRequired`),
-        status: 'fail',
-        failColor: 'white',
-        noIndent: true,
-      });
-      this.spinnies.add('manualUploadExplanation1', {
-        text: i18n(`${i18nKey}.upload.manualUploadExplanation1`),
-        status: 'non-spinnable',
-        indent: 1,
-      });
-      this.spinnies.add('manualUploadExplanation2', {
-        text: i18n(`${i18nKey}.upload.manualUploadExplanation2`),
-        status: 'non-spinnable',
-        indent: 1,
-      });
-      this.spinnies.add('manualUploadPrompt', {
-        text: i18n(`${i18nKey}.upload.manualUploadPrompt`),
-        status: 'non-spinnable',
-        indent: 1,
+      const addedToQueue = this.addChangeToStandbyQueue({
+        ...changeInfo,
+        supported: false,
       });
+
+      if (addedToQueue) {
+        SpinniesManager.add('manualUploadRequired', {
+          text: i18n(`${i18nKey}.upload.manualUploadRequired`),
+          status: 'fail',
+          failColor: 'white',
+          noIndent: true,
+        });
+        SpinniesManager.add('manualUploadExplanation1', {
+          text: i18n(`${i18nKey}.upload.manualUploadExplanation1`),
+          status: 'non-spinnable',
+          indent: 1,
+        });
+        SpinniesManager.add('manualUploadExplanation2', {
+          text: i18n(`${i18nKey}.upload.manualUploadExplanation2`),
+          status: 'non-spinnable',
+          indent: 1,
+        });
+        SpinniesManager.add('manualUploadPrompt', {
+          text: i18n(`${i18nKey}.upload.manualUploadPrompt`),
+          status: 'non-spinnable',
+          indent: 1,
+        });
+      }
     }
   }
 
@@ -392,14 +413,24 @@ class LocalDevManager {
     const { event, filePath } = changeInfo;
 
     if (event === WATCH_EVENTS.add || event === WATCH_EVENTS.change) {
-      if (!isAllowedExtension(filePath)) {
-        logger.debug(`Extension not allowed: ${filePath}`);
-        return;
+      if (!isAllowedExtension(filePath, ['jsx', 'tsx'])) {
+        SpinniesManager.add(null, {
+          text: i18n(`${i18nKey}.upload.extensionNotAllowed`, {
+            filePath,
+          }),
+          status: 'non-spinnable',
+        });
+        return false;
       }
     }
     if (shouldIgnoreFile(filePath, true)) {
-      logger.debug(`File ignored: ${filePath}`);
-      return;
+      SpinniesManager.add(null, {
+        text: i18n(`${i18nKey}.upload.fileIgnored`, {
+          filePath,
+        }),
+        status: 'non-spinnable',
+      });
+      return false;
     }
 
     const existingIndex = this.standbyChanges.findIndex(
@@ -412,6 +443,7 @@ class LocalDevManager {
     } else {
       this.standbyChanges.push(changeInfo);
     }
+    return true;
   }
 
   async sendChanges(changeInfo) {
@@ -419,7 +451,7 @@ class LocalDevManager {
 
     try {
       if (event === WATCH_EVENTS.add || event === WATCH_EVENTS.change) {
-        const spinniesKey = this.spinnies.add(null, {
+        const { name: spinnerName } = SpinniesManager.add(null, {
           text: i18n(`${i18nKey}.upload.uploadingAddChange`, {
             filePath: remotePath,
           }),
@@ -431,7 +463,7 @@ class LocalDevManager {
           filePath,
           remotePath
         );
-        this.spinnies.update(spinniesKey, {
+        SpinniesManager.update(spinnerName, {
           text: i18n(`${i18nKey}.upload.uploadedAddChange`, {
             filePath: remotePath,
           }),
@@ -441,18 +473,20 @@ class LocalDevManager {
         event === WATCH_EVENTS.unlink ||
         event === WATCH_EVENTS.unlinkDir
       ) {
-        const spinniesKey = this.spinnies.add(null, {
+        const { name: spinnerName } = SpinniesManager.add(null, {
           text: i18n(`${i18nKey}.upload.uploadingRemoveChange`, {
             filePath: remotePath,
           }),
           status: 'non-spinnable',
         });
+        const path =
+          event === WATCH_EVENTS.unlinkDir ? `${remotePath}/` : remotePath;
         await deleteFileFromBuild(
           this.targetAccountId,
           this.projectConfig.name,
-          remotePath
+          path
         );
-        this.spinnies.update(spinniesKey, {
+        SpinniesManager.update(spinnerName, {
           text: i18n(`${i18nKey}.upload.uploadedRemoveChange`, {
             filePath: remotePath,
           }),
@@ -487,7 +521,9 @@ class LocalDevManager {
   }
 
   async queueBuild() {
-    const spinniesKey = this.spinnies.add(null, {
+    SpinniesManager.add(null, { text: ' ', status: 'non-spinnable' });
+
+    const { name: spinnerName } = SpinniesManager.add(null, {
       text: i18n(`${i18nKey}.upload.uploadingChanges`, {
         accountIdentifier: uiAccountDescription(this.targetAccountId),
         buildId: this.currentStagedBuildId,
@@ -497,60 +533,94 @@ class LocalDevManager {
 
     await this.pauseUploadQueue();
 
+    let queueBuildError;
+
     try {
       await queueBuild(this.targetAccountId, this.projectConfig.name);
     } catch (err) {
-      logger.debug(err);
-      if (
-        isSpecifiedError(err, {
-          subCategory: ERROR_TYPES.MISSING_PROJECT_PROVISION,
-        })
-      ) {
-        logger.log(i18n(`${i18nKey}.cancelledFromUI`));
-        this.stop();
-      } else {
-        logApiErrorInstance(
-          err,
-          new ApiErrorContext({
-            accountId: this.targetAccountId,
-            projectName: this.projectConfig.name,
-          })
-        );
-      }
-      return;
+      queueBuildError = err;
     }
 
-    const result = await pollProjectBuildAndDeploy(
-      this.targetAccountId,
-      this.projectConfig,
-      null,
-      this.currentStagedBuildId,
-      true
-    );
+    if (queueBuildError) {
+      this.updateDevModeStatus('buildError');
 
-    if (result && result.succeeded) {
-      this.spinnies.succeed(spinniesKey, {
-        text: i18n(`${i18nKey}.upload.uploadedChangesSucceeded`, {
-          accountIdentifier: uiAccountDescription(this.targetAccountId),
-          buildId: result.buildId,
-        }),
-        succeedColor: 'white',
-        noIndent: true,
-      });
-    } else {
-      this.spinnies.fail(spinniesKey, {
+      logger.debug(queueBuildError);
+
+      SpinniesManager.fail(spinnerName, {
         text: i18n(`${i18nKey}.upload.uploadedChangesFailed`, {
           accountIdentifier: uiAccountDescription(this.targetAccountId),
-          buildId: result.buildId,
+          buildId: this.currentStagedBuildId,
         }),
         failColor: 'white',
         noIndent: true,
       });
+
+      if (
+        isSpecifiedError(queueBuildError, {
+          subCategory: ERROR_TYPES.MISSING_PROJECT_PROVISION,
+        })
+      ) {
+        SpinniesManager.add(null, {
+          text: i18n(`${i18nKey}.cancelledFromUI`),
+          status: 'non-spinnable',
+          indent: 1,
+        });
+        this.stop();
+      } else if (
+        queueBuildError &&
+        queueBuildError.error &&
+        queueBuildError.error.message
+      ) {
+        SpinniesManager.add(null, {
+          text: queueBuildError.error.message,
+          status: 'non-spinnable',
+          indent: 1,
+        });
+      }
+    } else {
+      const result = await pollProjectBuildAndDeploy(
+        this.targetAccountId,
+        this.projectConfig,
+        null,
+        this.currentStagedBuildId,
+        true
+      );
+
+      if (result.succeeded) {
+        this.updateDevModeStatus('clean');
+
+        SpinniesManager.succeed(spinnerName, {
+          text: i18n(`${i18nKey}.upload.uploadedChangesSucceeded`, {
+            accountIdentifier: uiAccountDescription(this.targetAccountId),
+            buildId: result.buildId,
+          }),
+          succeedColor: 'white',
+          noIndent: true,
+        });
+      } else {
+        SpinniesManager.fail(spinnerName, {
+          text: i18n(`${i18nKey}.upload.uploadedChangesFailed`, {
+            accountIdentifier: uiAccountDescription(this.targetAccountId),
+            buildId: result.buildId,
+          }),
+          failColor: 'white',
+          noIndent: true,
+        });
+
+        if (result.buildResult.status === 'FAILURE') {
+          this.logBuildError(result.buildResult);
+        } else if (result.deployResult.status === 'FAILURE') {
+          this.logDeployError(result.deployResult);
+        }
+      }
     }
 
-    this.spinnies.removeAll({ targetCategory: 'projectPollStatus' });
+    SpinniesManager.removeAll({ targetCategory: 'projectPollStatus' });
 
-    if (this.uploadPermission === UPLOAD_PERMISSIONS.always) {
+    if (
+      !queueBuildError &&
+      this.uploadPermission === UPLOAD_PERMISSIONS.always
+    ) {
       await this.createNewStagingBuild();
     }
 
@@ -558,14 +628,12 @@ class LocalDevManager {
 
     if (this.hasAnyUnsupportedStandbyChanges()) {
       this.flushStandbyChanges();
-    } else {
-      this.updateDevModeStatus('clean');
     }
   }
 
-  async flushStandbyChanges() {
+  flushStandbyChanges() {
     if (this.standbyChanges.length) {
-      await this.uploadQueue.addAll(
+      this.uploadQueue.addAll(
         this.standbyChanges.map(changeInfo => {
           return async () => {
             if (
@@ -586,25 +654,45 @@ class LocalDevManager {
     await this.watcher.close();
   }
 
-  async startServers() {
-    this.devServerPath = await DevServerManager.start({
-      accountId: this.targetAccountId,
-      projectConfig: this.projectConfig,
-      port: this.port,
+  handleServerLog(serverKey, ...args) {
+    SpinniesManager.add(null, {
+      text: `${args.join('')}`,
+      status: 'non-spinnable',
     });
   }
 
-  async notifyServers(changeInfo) {
-    const notifyResponse = await DevServerManager.notify(changeInfo);
-    return notifyResponse;
-  }
-
-  async executeServers(notifyResponse, changeInfo) {
-    await DevServerManager.execute(notifyResponse, changeInfo);
+  async devServerStart() {
+    try {
+      await DevServerManager.start({
+        accountId: this.targetAccountId,
+        debug: this.debug,
+        spinniesLogger: this.handleServerLog,
+        projectConfig: this.projectConfig,
+        projectSourceDir: this.projectSourceDir,
+      });
+    } catch (e) {
+      if (this.debug) {
+        logger.error(e);
+      }
+      SpinniesManager.add(null, {
+        text: i18n(`${i18nKey}.devServer.startError`),
+        status: 'non-spinnable',
+      });
+    }
   }
 
-  async cleanupServers() {
-    await DevServerManager.cleanup();
+  async devServerCleanup() {
+    try {
+      await DevServerManager.cleanup();
+    } catch (e) {
+      if (this.debug) {
+        logger.error(e);
+      }
+      SpinniesManager.add(null, {
+        text: i18n(`${i18nKey}.devServer.cleanupError`),
+        status: 'non-spinnable',
+      });
+    }
   }
 }