@hubspot/cli 4.1.8-beta.1 → 4.1.8-beta.2

package/lib/LocalDevManager.js

@@ -0,0 +1,526 @@
+const chokidar = require('chokidar');
+const path = require('path');
+const { default: PQueue } = require('p-queue');
+const { i18n } = require('@hubspot/cli-lib/lib/lang');
+const { logger } = require('@hubspot/cli-lib/logger');
+const {
+  isSpecifiedError,
+} = require('@hubspot/cli-lib/errorHandlers/apiErrors');
+const { handleKeypress } = require('@hubspot/cli-lib/lib/process');
+const {
+  logApiErrorInstance,
+  ApiErrorContext,
+} = require('@hubspot/cli-lib/errorHandlers');
+const { ERROR_TYPES } = require('@hubspot/cli-lib/lib/constants');
+const { isAllowedExtension } = require('@hubspot/cli-lib/path');
+const { shouldIgnoreFile } = require('@hubspot/cli-lib/ignoreRules');
+const {
+  cancelStagedBuild,
+  uploadFileToBuild,
+  deleteFileFromBuild,
+  provisionBuild,
+  queueBuild,
+} = require('@hubspot/cli-lib/api/dfs');
+const SpinniesManager = require('./SpinniesManager');
+const { EXIT_CODES } = require('./enums/exitCodes');
+const {
+  getProjectDetailUrl,
+  pollProjectBuildAndDeploy,
+} = require('./projects');
+const { uiAccountDescription, uiLink } = require('./ui');
+
+const i18nKey = 'cli.lib.LocalDevManager';
+
+const BUILD_DEBOUNCE_TIME = 2000;
+
+const WATCH_EVENTS = {
+  add: 'add',
+  change: 'change',
+  unlink: 'unlink',
+  unlinkDir: 'unlinkDir',
+};
+
+const UPLOAD_PERMISSIONS = {
+  always: 'always',
+  manual: 'manual',
+  never: 'never',
+};
+class LocalDevManager {
+  constructor(options) {
+    this.targetAccountId = options.targetAccountId;
+    this.projectConfig = options.projectConfig;
+    this.projectDir = options.projectDir;
+    this.uploadPermission =
+      options.uploadPermission || UPLOAD_PERMISSIONS.always;
+    this.debug = options.debug || false;
+    this.mockServers = options.mockServers || 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;
+
+    if (!this.targetAccountId || !this.projectConfig || !this.projectDir) {
+      process.exit(EXIT_CODES.ERROR);
+    }
+  }
+
+  async start() {
+    this.spinnies = SpinniesManager.init();
+
+    this.watcher = chokidar.watch(this.projectSourceDir, {
+      ignoreInitial: true,
+      ignored: file => shouldIgnoreFile(file),
+    });
+
+    this.uploadQueue = new PQueue({ concurrency: 10 });
+
+    if (this.debug) {
+      this.uploadQueue.on('error', error => {
+        logger.debug(error);
+      });
+    }
+
+    console.clear();
+
+    this.uploadQueue.start();
+
+    this.logConsoleHeader();
+    await this.startServers();
+    await this.startWatching();
+    this.updateKeypressListeners();
+  }
+
+  async stop() {
+    this.clearConsoleContent();
+
+    this.spinnies.add('cleanupMessage', {
+      text: i18n(`${i18nKey}.exitingStart`),
+    });
+
+    await this.stopWatching();
+
+    await this.cleanupServers();
+
+    let exitCode = EXIT_CODES.SUCCESS;
+
+    if (this.currentStagedBuildId) {
+      try {
+        await cancelStagedBuild(this.targetAccountId, this.projectConfig.name);
+      } catch (err) {
+        if (
+          !isSpecifiedError(err, {
+            subCategory: ERROR_TYPES.BUILD_NOT_IN_PROGRESS,
+          })
+        ) {
+          logApiErrorInstance(
+            err,
+            new ApiErrorContext({
+              accountId: this.targetAccountId,
+              projectName: this.projectConfig.name,
+            })
+          );
+          exitCode = EXIT_CODES.ERROR;
+        }
+      }
+    }
+
+    if (exitCode === EXIT_CODES.SUCCESS) {
+      this.spinnies.succeed('cleanupMessage', {
+        text: i18n(`${i18nKey}.exitingSucceed`),
+      });
+    } else {
+      this.spinnies.fail('cleanupMessage', {
+        text: i18n(`${i18nKey}.exitingFail`),
+      });
+    }
+
+    process.exit(exitCode);
+  }
+
+  logConsoleHeader() {
+    this.spinnies.removeAll();
+    this.spinnies.add('devModeRunning', {
+      text: i18n(`${i18nKey}.running`),
+      isParent: true,
+      category: 'header',
+    });
+    this.spinnies.add('devModeStatus', {
+      text: i18n(`${i18nKey}.status.clean`),
+      status: 'non-spinnable',
+      indent: 1,
+      category: 'header',
+    });
+    const projectDetailUrl = getProjectDetailUrl(
+      this.projectConfig.name,
+      this.targetAccountId
+    );
+    this.spinnies.add('viewInHubSpotLink', {
+      text: uiLink(i18n(`${i18nKey}.viewInHubSpot`), projectDetailUrl, {
+        inSpinnies: true,
+      }),
+      status: 'non-spinnable',
+      indent: 1,
+      category: 'header',
+    });
+    this.spinnies.add('spacer-1', {
+      text: ' ',
+      status: 'non-spinnable',
+      category: 'header',
+    });
+    this.spinnies.add('keypressMessage', {
+      text: i18n(`${i18nKey}.quitHelper`),
+      status: 'non-spinnable',
+      indent: 1,
+      category: 'header',
+    });
+    this.spinnies.add('lineSeparator', {
+      text: '-'.repeat(50),
+      status: 'non-spinnable',
+      noIndent: true,
+      category: 'header',
+    });
+  }
+
+  clearConsoleContent() {
+    this.spinnies.removeAll({ preserveCategory: 'header' });
+  }
+
+  updateKeypressListeners() {
+    handleKeypress(async key => {
+      if ((key.ctrl && key.name === 'c') || key.name === 'q') {
+        this.stop();
+      } else if (key.name === 'y') {
+        if (
+          this.uploadPermission === UPLOAD_PERMISSIONS.manual &&
+          this.hasAnyUnsupportedStandbyChanges()
+        ) {
+          this.clearConsoleContent();
+          this.updateDevModeStatus('manualUpload');
+          await this.createNewStagingBuild();
+          await this.flushStandbyChanges();
+          await this.queueBuild();
+        }
+      } else if (key.name === 'n') {
+        if (
+          this.uploadPermission === UPLOAD_PERMISSIONS.manual &&
+          this.hasAnyUnsupportedStandbyChanges()
+        ) {
+          this.clearConsoleContent();
+          this.spinnies.add('manualUploadSkipped', {
+            text: i18n(`${i18nKey}.upload.manualUploadSkipped`),
+            status: 'fail',
+            failColor: 'white',
+            noIndent: true,
+          });
+        }
+      }
+    });
+  }
+
+  updateDevModeStatus(langKey) {
+    this.spinnies.update('devModeStatus', {
+      text: i18n(`${i18nKey}.status.${langKey}`),
+      status: 'non-spinnable',
+      noIndent: true,
+    });
+  }
+
+  async pauseUploadQueue() {
+    this.spinnies.add('uploading', {
+      text: i18n(`${i18nKey}.upload.uploadingChanges`, {
+        accountIdentifier: uiAccountDescription(this.targetAccountId),
+      }),
+      noIndent: true,
+    });
+
+    this.uploadQueue.pause();
+    await this.uploadQueue.onIdle();
+  }
+
+  hasAnyUnsupportedStandbyChanges() {
+    return this.standbyChanges.some(({ supported }) => !supported);
+  }
+
+  async createNewStagingBuild() {
+    try {
+      const { buildId } = await provisionBuild(
+        this.targetAccountId,
+        this.projectConfig.name
+      );
+      this.currentStagedBuildId = buildId;
+    } catch (err) {
+      logger.debug(err);
+      if (isSpecifiedError(err, { subCategory: ERROR_TYPES.PROJECT_LOCKED })) {
+        await cancelStagedBuild(this.targetAccountId, this.projectConfig.name);
+        logger.log(i18n(`${i18nKey}.previousStagingBuildCancelled`));
+      }
+      process.exit(EXIT_CODES.ERROR);
+    }
+  }
+
+  async startWatching() {
+    if (this.uploadPermission === UPLOAD_PERMISSIONS.always) {
+      await this.createNewStagingBuild();
+    }
+
+    this.watcher.on('add', async filePath => {
+      this.handleWatchEvent(filePath, WATCH_EVENTS.add);
+    });
+    this.watcher.on('change', async filePath => {
+      this.handleWatchEvent(filePath, WATCH_EVENTS.change);
+    });
+    this.watcher.on('unlink', async filePath => {
+      this.handleWatchEvent(filePath, WATCH_EVENTS.unlink);
+    });
+    this.watcher.on('unlinkDir', async filePath => {
+      this.handleWatchEvent(filePath, WATCH_EVENTS.unlinkDir);
+    });
+  }
+
+  async handleWatchEvent(filePath, event) {
+    const changeInfo = {
+      event,
+      filePath,
+      remotePath: path.relative(this.projectSourceDir, filePath),
+    };
+
+    const isSupportedChange = await this.notifyServers(changeInfo);
+
+    if (isSupportedChange) {
+      this.updateDevModeStatus('supportedChange');
+      this.addChangeToStandbyQueue({ ...changeInfo, supported: true });
+      return;
+    }
+
+    if (this.uploadPermission !== UPLOAD_PERMISSIONS.always) {
+      this.handlePreventedUpload(changeInfo);
+      return;
+    }
+
+    if (this.uploadQueue.isPaused) {
+      if (
+        !this.standbyChanges.find(
+          changeInfo => changeInfo.filePath === filePath
+        )
+      ) {
+        this.addChangeToStandbyQueue({ ...changeInfo, supported: false });
+      }
+    } else {
+      await this.flushStandbyChanges();
+
+      if (!this.uploadQueue.isPaused) {
+        this.debounceQueueBuild();
+      }
+
+      return this.uploadQueue.add(async () => {
+        await this.sendChanges(changeInfo);
+      });
+    }
+  }
+
+  handlePreventedUpload(changeInfo) {
+    const { remotePath } = changeInfo;
+
+    this.clearConsoleContent();
+    if (this.uploadPermission === UPLOAD_PERMISSIONS.never) {
+      this.updateDevModeStatus('noUploadsAllowed');
+
+      this.spinnies.add('noUploadsAllowed', {
+        text: i18n(`${i18nKey}.upload.noUploadsAllowed`, {
+          filePath: remotePath,
+        }),
+        status: 'fail',
+        failColor: 'white',
+        noIndent: true,
+      });
+    } 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,
+      });
+    }
+  }
+
+  addChangeToStandbyQueue(changeInfo) {
+    const { event, filePath } = changeInfo;
+
+    if (event === WATCH_EVENTS.add || event === WATCH_EVENTS.change) {
+      if (!isAllowedExtension(filePath)) {
+        logger.debug(`Extension not allowed: ${filePath}`);
+        return;
+      }
+    }
+    if (shouldIgnoreFile(filePath, true)) {
+      logger.debug(`File ignored: ${filePath}`);
+      return;
+    }
+    this.standbyChanges.push(changeInfo);
+  }
+
+  async sendChanges(changeInfo) {
+    const { event, filePath, remotePath } = changeInfo;
+
+    this.spinnies.add(filePath, {
+      text: i18n(`${i18nKey}.upload.uploadingChange`, {
+        filePath: remotePath,
+      }),
+      status: 'non-spinnable',
+    });
+    try {
+      if (event === WATCH_EVENTS.add || event === WATCH_EVENTS.change) {
+        await uploadFileToBuild(
+          this.targetAccountId,
+          this.projectConfig.name,
+          filePath,
+          remotePath
+        );
+      } else if (
+        event === WATCH_EVENTS.unlink ||
+        event === WATCH_EVENTS.unlinkDir
+      ) {
+        await deleteFileFromBuild(
+          this.targetAccountId,
+          this.projectConfig.name,
+          remotePath
+        );
+      }
+    } catch (err) {
+      logger.debug(err);
+    }
+  }
+
+  debounceQueueBuild() {
+    if (this.uploadPermission === UPLOAD_PERMISSIONS.always) {
+      this.updateDevModeStatus('uploadPending');
+    }
+
+    if (this.debouncedBuild) {
+      clearTimeout(this.debouncedBuild);
+    }
+
+    this.debouncedBuild = setTimeout(
+      this.queueBuild.bind(this),
+      BUILD_DEBOUNCE_TIME
+    );
+  }
+
+  async queueBuild() {
+    await this.pauseUploadQueue();
+
+    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;
+    }
+
+    await pollProjectBuildAndDeploy(
+      this.targetAccountId,
+      this.projectConfig,
+      null,
+      this.currentStagedBuildId,
+      true
+    );
+
+    if (this.uploadPermission === UPLOAD_PERMISSIONS.always) {
+      await this.createNewStagingBuild();
+    }
+
+    this.uploadQueue.start();
+    this.clearConsoleContent();
+
+    if (this.hasAnyUnsupportedStandbyChanges()) {
+      this.flushStandbyChanges();
+    } else {
+      this.updateDevModeStatus('clean');
+    }
+  }
+
+  async flushStandbyChanges() {
+    if (this.standbyChanges.length) {
+      await this.uploadQueue.addAll(
+        this.standbyChanges.map(changeInfo => {
+          return async () => {
+            if (
+              this.uploadPermission === UPLOAD_PERMISSIONS.always &&
+              !this.uploadQueue.isPaused
+            ) {
+              this.debounceQueueBuild();
+            }
+            await this.sendChanges(changeInfo);
+          };
+        })
+      );
+      this.standbyChanges = [];
+    }
+  }
+
+  async stopWatching() {
+    await this.watcher.close();
+  }
+
+  async startServers() {
+    // TODO spin up local dev servers
+    return true;
+  }
+
+  async notifyServers(changeInfo) {
+    const { remotePath } = changeInfo;
+
+    // TODO notify servers of the change
+    if (this.mockServers) {
+      return !remotePath.endsWith('app.json');
+    }
+    return false;
+  }
+
+  async cleanupServers() {
+    // TODO tell servers to cleanup
+    return;
+  }
+}
+
+module.exports = { LocalDevManager, UPLOAD_PERMISSIONS };

package/lib/SpinniesManager.js

@@ -0,0 +1,96 @@
+const Spinnies = require('spinnies');
+
+// Allows us to maintain a single instance of spinnies across multiple files
+class SpinniesManager {
+  constructor() {
+    this.spinnies = null;
+    this.parentKey = null;
+    this.categories = {};
+  }
+
+  init(options) {
+    if (!this.spinnies) {
+      this.spinnies = new Spinnies(options);
+    }
+
+    return {
+      add: this.add.bind(this),
+      pick: this.spinnies.pick.bind(this.spinnies),
+      remove: this.remove.bind(this),
+      removeAll: this.removeAll.bind(this),
+      update: this.spinnies.update.bind(this.spinnies),
+      succeed: this.spinnies.succeed.bind(this.spinnies),
+      fail: this.spinnies.fail.bind(this.spinnies),
+      stopAll: this.spinnies.stopAll.bind(this.spinnies),
+      hasActiveSpinners: this.spinnies.hasActiveSpinners.bind(this.spinnies),
+    };
+  }
+
+  addKeyToCategory(key, category) {
+    if (!this.categories[category]) {
+      this.categories[category] = [];
+    }
+    this.categories[category].push(key);
+  }
+
+  getCategoryForKey(key) {
+    return Object.keys(this.categories).find(category =>
+      this.categories[category].find(k => k === key)
+    );
+  }
+
+  removeKeyFromCategory(key) {
+    const category = this.getCategoryForKey(key);
+    if (category) {
+      const index = this.categories[category].indexOf(key);
+      this.categories[category].splice(index, 1);
+    }
+  }
+
+  add(key, options = {}) {
+    const { category, isParent, noIndent, ...rest } = options;
+    const originalIndent = rest.indent || 0;
+
+    if (category) {
+      this.addKeyToCategory(key, category);
+    }
+
+    this.spinnies.add(key, {
+      ...rest,
+      indent: this.parentKey && !noIndent ? originalIndent + 1 : originalIndent,
+    });
+
+    if (isParent) {
+      this.parentKey = key;
+    }
+  }
+
+  remove(key) {
+    if (this.spinnies) {
+      if (key === this.parentKey) {
+        this.parentKey = null;
+      }
+      this.removeKeyFromCategory(key);
+      this.spinnies.remove(key);
+    }
+  }
+
+  /**
+   * Removes all spinnies instances
+   * @param {string} preserveCategory - do not remove spinnies with a matching category
+   */
+  removeAll({ preserveCategory = null } = {}) {
+    if (this.spinnies) {
+      Object.keys(this.spinnies.spinners).forEach(key => {
+        if (
+          !preserveCategory ||
+          this.getCategoryForKey(key) !== preserveCategory
+        ) {
+          this.remove(key);
+        }
+      });
+    }
+  }
+}
+
+module.exports = new SpinniesManager();