@hubspot/cli 3.0.9 → 3.0.10-beta.11

package/lib/projects.js

@@ -1,4 +1,4 @@
-const fs = require('fs');
+const fs = require('fs-extra');
 const path = require('path');
 
 const chalk = require('chalk');
@@ -7,35 +7,61 @@ const { prompt } = require('inquirer');
 const Spinnies = require('spinnies');
 const { logger } = require('@hubspot/cli-lib/logger');
 const { getEnv } = require('@hubspot/cli-lib/lib/config');
+const {
+  createProject: createProjectTemplate,
+} = require('@hubspot/cli-lib/projects');
 const { getHubSpotWebsiteOrigin } = require('@hubspot/cli-lib/lib/urls');
 const {
   ENVIRONMENTS,
   POLLING_DELAY,
-  PROJECT_BUILD_STATUS,
-  PROJECT_BUILD_STATUS_TEXT,
-  PROJECT_DEPLOY_STATUS,
-  PROJECT_DEPLOY_STATUS_TEXT,
+  PROJECT_TEMPLATES,
+  PROJECT_TEXT,
+  PROJECT_CONFIG_FILE,
 } = require('@hubspot/cli-lib/lib/constants');
 const {
+  createProject,
   getBuildStatus,
   getDeployStatus,
   fetchProject,
-  createProject,
 } = require('@hubspot/cli-lib/api/dfs');
 const {
   logApiErrorInstance,
   ApiErrorContext,
 } = require('@hubspot/cli-lib/errorHandlers');
-
-const isBuildComplete = build => {
-  return (
-    build.status === PROJECT_BUILD_STATUS.SUCCESS ||
-    build.status === PROJECT_BUILD_STATUS.FAILURE
-  );
+const { getCwd } = require('@hubspot/cli-lib/path');
+const { EXIT_CODES } = require('./enums/exitCodes');
+const { uiLine, uiAccountDescription } = require('../lib/ui');
+
+const PROJECT_STRINGS = {
+  BUILD: {
+    INITIALIZE: (name, numOfComponents) =>
+      `Building ${chalk.bold(name)}\n\nFound ${numOfComponents} component${
+        numOfComponents !== 1 ? 's' : ''
+      } in this project ...\n`,
+    SUCCESS: name => `Built ${chalk.bold(name)}`,
+    FAIL: name => `Failed to build ${chalk.bold(name)}`,
+    SUBTASK_FAIL: (taskId, name) =>
+      `Build #${taskId} failed because there was a problem\nbuilding ${chalk.bold(
+        name
+      )}`,
+  },
+  DEPLOY: {
+    INITIALIZE: (name, numOfComponents) =>
+      `Deploying ${chalk.bold(name)}\n\nFound ${numOfComponents} component${
+        numOfComponents !== 1 ? 's' : ''
+      } in this project ...\n`,
+    SUCCESS: name => `Deployed ${chalk.bold(name)}`,
+    FAIL: name => `Failed to deploy ${chalk.bold(name)}`,
+    SUBTASK_FAIL: (taskId, name) =>
+      `Deploy for build #${taskId} failed because there was a\nproblem deploying ${chalk.bold(
+        name
+      )}`,
+  },
 };
 
 const writeProjectConfig = (configPath, config) => {
   try {
+    fs.ensureFileSync(configPath);
     fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
     logger.debug(`Wrote project config at ${configPath}`);
   } catch (e) {
@@ -43,55 +69,83 @@ const writeProjectConfig = (configPath, config) => {
   }
 };
 
-const getProjectConfig = async projectPath => {
-  const configPath = findup('hsproject.json', {
-    cwd: projectPath,
+const getProjectConfig = async _dir => {
+  const projectDir = _dir ? path.resolve(getCwd(), _dir) : getCwd();
+
+  const configPath = findup(PROJECT_CONFIG_FILE, {
+    cwd: projectDir,
     nocase: true,
   });
 
   if (!configPath) {
-    return null;
+    return { projectConfig: null, projectDir: null };
   }
 
   try {
-    const projectConfig = fs.readFileSync(configPath);
-    return JSON.parse(projectConfig);
+    const config = fs.readFileSync(configPath);
+    const projectConfig = JSON.parse(config);
+    return {
+      projectDir: path.dirname(configPath),
+      projectConfig,
+    };
   } catch (e) {
     logger.error('Could not read from project config');
   }
 };
 
-const getOrCreateProjectConfig = async projectPath => {
-  const projectConfig = await getProjectConfig(projectPath);
+const createProjectConfig = async (projectPath, projectName, template) => {
+  const { projectConfig, projectDir } = await getProjectConfig(projectPath);
 
-  if (!projectConfig) {
-    const { name, srcDir } = await prompt([
-      {
-        name: 'name',
-        message: 'Please enter a project name:',
-        validate: input => {
-          if (!input) {
-            return 'A project name is required';
-          }
-          return true;
-        },
-      },
+  if (projectConfig) {
+    logger.warn(
+      projectPath === projectDir
+        ? 'A project already exists in that location.'
+        : `Found an existing project definition in ${projectDir}.`
+    );
+
+    const { shouldContinue } = await prompt([
       {
-        name: 'srcDir',
-        message: 'Which directory contains your project files?',
-        validate: input => {
-          if (!input) {
-            return 'A source directory is required';
-          }
-          return true;
+        name: 'shouldContinue',
+        message: () => {
+          return projectPath === projectDir
+            ? 'Do you want to overwrite the existing project definition with a new one?'
+            : `Continue creating a new project in ${projectPath}?`;
         },
+        type: 'confirm',
+        default: false,
       },
     ]);
-    writeProjectConfig(path.join(projectPath, 'hsproject.json'), {
-      name,
-      srcDir,
+
+    if (!shouldContinue) {
+      return;
+    }
+  }
+
+  const projectConfigPath = path.join(projectPath, PROJECT_CONFIG_FILE);
+
+  logger.log(
+    `Creating project in ${projectPath ? projectPath : 'the current folder'}`
+  );
+
+  if (template === 'none') {
+    fs.ensureDirSync(path.join(projectPath, 'src'));
+
+    writeProjectConfig(projectConfigPath, {
+      name: projectName,
+      srcDir: 'src',
+    });
+  } else {
+    await createProjectTemplate(
+      projectPath,
+      'project',
+      PROJECT_TEMPLATES.find(t => t.name === template).repo,
+      ''
+    );
+    const _config = JSON.parse(fs.readFileSync(projectConfigPath));
+    writeProjectConfig(projectConfigPath, {
+      ..._config,
+      name: projectName,
     });
-    return { name, srcDir };
   }
 
   return projectConfig;
@@ -100,38 +154,45 @@ const getOrCreateProjectConfig = async projectPath => {
 const validateProjectConfig = (projectConfig, projectDir) => {
   if (!projectConfig) {
     logger.error(
-      `Project config not found. Try running 'hs project init' first.`
+      `Project config not found. Try running 'hs project create' first.`
     );
-    process.exit(1);
+    process.exit(EXIT_CODES.ERROR);
   }
 
   if (!projectConfig.name || !projectConfig.srcDir) {
     logger.error(
-      'Project config is missing required fields. Try running `hs project init`.'
+      'Project config is missing required fields. Try running `hs project create`.'
     );
-    process.exit(1);
+    process.exit(EXIT_CODES.ERROR);
   }
 
   if (!fs.existsSync(path.resolve(projectDir, projectConfig.srcDir))) {
     logger.error(
-      `Project source directory '${projectConfig.srcDir}' does not exist.`
+      `Project source directory '${projectConfig.srcDir}' could not be found in ${projectDir}.`
     );
-    process.exit(1);
+    process.exit(EXIT_CODES.ERROR);
   }
 };
 
-const ensureProjectExists = async (accountId, projectName) => {
+const ensureProjectExists = async (accountId, projectName, forceCreate) => {
   try {
     await fetchProject(accountId, projectName);
   } catch (err) {
     if (err.statusCode === 404) {
-      const { shouldCreateProject } = await prompt([
-        {
-          name: 'shouldCreateProject',
-          message: `The project ${projectName} does not exist in ${accountId}. Would you like to create it?`,
-          type: 'confirm',
-        },
-      ]);
+      let shouldCreateProject = forceCreate;
+
+      if (!shouldCreateProject) {
+        const promptResult = await prompt([
+          {
+            name: 'shouldCreateProject',
+            message: `The project ${projectName} does not exist in ${uiAccountDescription(
+              accountId
+            )}. Would you like to create it?`,
+            type: 'confirm',
+          },
+        ]);
+        shouldCreateProject = promptResult.shouldCreateProject;
+      }
 
       if (shouldCreateProject) {
         try {
@@ -161,219 +222,169 @@ const getProjectDetailUrl = (projectName, accountId) => {
   return `${baseUrl}/developer-projects/${accountId}/project/${projectName}`;
 };
 
-const showWelcomeMessage = (projectName, accountId) => {
-  const projectDetailUrl = getProjectDetailUrl(projectName, accountId);
-
+const showWelcomeMessage = () => {
   logger.log('');
-  logger.log(chalk.bold('> Welcome to HubSpot Developer Projects!'));
+  logger.log(chalk.bold('Welcome to HubSpot Developer Projects!'));
   logger.log(
     '\n-------------------------------------------------------------\n'
   );
-  if (projectDetailUrl) {
-    logger.log(chalk.italic(`View this project at: ${projectDetailUrl}`));
-  }
-  logger.log('');
-  logger.log(chalk.bold('Getting Started'));
-  logger.log('');
-  logger.log('1. hs project upload');
+  logger.log(chalk.bold("What's next?\n"));
+  logger.log('🎨 Add components to your project with `hs create`.\n');
   logger.log(
-    '   Upload your project files to HubSpot. Upload action adds your files to a build.'
+    `🏗  Run \`hs project upload\` to upload your files to HubSpot and trigger builds.\n`
   );
-  logger.log();
-  logger.log('2. View your changes on the preview build url');
-  logger.log();
-  logger.log('Use `hs project --help` to learn more about the command.');
   logger.log(
-    '\n-------------------------------------------------------------\n'
+    `🚀 Ready to take your project live? Run \`hs project deploy\`.\n`
   );
+  logger.log(
+    `🔗 Use \`hs project --help\` to learn more about available commands.\n`
+  );
+  logger.log('-------------------------------------------------------------');
 };
 
-const pollBuildStatus = async (accountId, name, buildId) => {
-  const buildStatus = await getBuildStatus(accountId, name, buildId);
-  const spinnies = new Spinnies();
-
-  logger.log();
-  logger.log(`Building ${chalk.bold(name)}`);
-  logger.log();
-  logger.log(`Found ${buildStatus.subbuildStatuses.length} deployables ...`);
-  logger.log();
-
-  for (let subBuild of buildStatus.subbuildStatuses) {
-    spinnies.add(subBuild.buildName, {
-      text: `${chalk.bold(subBuild.buildName)} #${buildId} ${
-        PROJECT_BUILD_STATUS_TEXT[PROJECT_BUILD_STATUS.ENQUEUED]
-      }`,
-    });
+const makeGetTaskStatus = taskType => {
+  let statusFn, statusText, statusStrings;
+  switch (taskType) {
+    case 'build':
+      statusFn = getBuildStatus;
+      statusText = PROJECT_TEXT.BUILD;
+      statusStrings = PROJECT_STRINGS.BUILD;
+      break;
+    case 'deploy':
+      statusFn = getDeployStatus;
+      statusText = PROJECT_TEXT.DEPLOY;
+      statusStrings = PROJECT_STRINGS.DEPLOY;
+      break;
+    default:
+      logger.error(`Cannot get status for task type ${taskType}`);
   }
 
-  return new Promise((resolve, reject) => {
-    const pollInterval = setInterval(async () => {
-      const buildStatus = await getBuildStatus(accountId, name, buildId).catch(
-        reject
-      );
-      const { status, subbuildStatuses } = buildStatus;
-
-      if (spinnies.hasActiveSpinners()) {
-        subbuildStatuses.forEach(subBuild => {
-          if (!spinnies.pick(subBuild.buildName)) {
-            return;
-          }
-
-          const updatedText = `${chalk.bold(subBuild.buildName)} #${buildId} ${
-            PROJECT_BUILD_STATUS_TEXT[subBuild.status]
-          }`;
-
-          switch (subBuild.status) {
-            case PROJECT_BUILD_STATUS.SUCCESS:
-              spinnies.succeed(subBuild.buildName, {
-                text: updatedText,
-              });
-              break;
-            case PROJECT_BUILD_STATUS.FAILURE:
-              spinnies.fail(subBuild.buildName, {
-                text: updatedText,
-              });
-              break;
-            default:
-              spinnies.update(subBuild.buildName, {
-                text: updatedText,
-              });
-              break;
-          }
-        });
+  return async (accountId, taskName, taskId, buildId) => {
+    const isTaskComplete = task => {
+      if (task.status === statusText.STATES.FAILURE) {
+        return true;
+      } else if (task.status === statusText.STATES.SUCCESS) {
+        return task.isAutoDeployEnabled ? !!task.deployStatusTaskLocator : true;
       }
+    };
 
-      if (isBuildComplete(buildStatus)) {
-        clearInterval(pollInterval);
-
-        if (status === PROJECT_BUILD_STATUS.SUCCESS) {
-          logger.success(
-            `Your project ${chalk.bold(name)} ${
-              PROJECT_BUILD_STATUS_TEXT[status]
-            }.`
-          );
-        } else if (status === PROJECT_BUILD_STATUS.FAILURE) {
-          logger.error(
-            `Your project ${chalk.bold(name)} ${
-              PROJECT_BUILD_STATUS_TEXT[status]
-            }.`
-          );
-          subbuildStatuses.forEach(subBuild => {
-            if (subBuild.status === PROJECT_BUILD_STATUS.FAILURE) {
-              logger.error(
-                `${chalk.bold(subBuild.buildName)} failed to build. ${
-                  subBuild.errorMessage
-                }.`
-              );
-            }
-          });
-        }
-        resolve(buildStatus);
-      }
-    }, POLLING_DELAY);
-  });
-};
+    const spinnies = new Spinnies({
+      succeedColor: 'white',
+      failColor: 'white',
+    });
 
-const pollDeployStatus = async (accountId, name, deployId, deployedBuildId) => {
-  const deployStatus = await getDeployStatus(accountId, name, deployId);
-  const spinnies = new Spinnies();
+    spinnies.add('overallTaskStatus', { text: 'Beginning' });
 
-  logger.log();
-  logger.log(`Deploying ${chalk.bold(name)}`);
-  logger.log();
-  logger.log(
-    `Found ${deployStatus.subdeployStatuses.length} sub-build deploys ...`
-  );
-  logger.log();
+    const initialTaskStatus = await statusFn(accountId, taskName, taskId);
 
-  for (let subdeploy of deployStatus.subdeployStatuses) {
-    spinnies.add(subdeploy.deployName, {
-      text: `${chalk.bold(subdeploy.deployName)} #${deployedBuildId} ${
-        PROJECT_DEPLOY_STATUS_TEXT[PROJECT_DEPLOY_STATUS.ENQUEUED]
-      }`,
+    spinnies.update('overallTaskStatus', {
+      text: statusStrings.INITIALIZE(
+        taskName,
+        initialTaskStatus[statusText.SUBTASK_KEY].length
+      ),
     });
-  }
 
-  return new Promise((resolve, reject) => {
-    const pollInterval = setInterval(async () => {
-      const deployStatus = await getDeployStatus(
-        accountId,
-        name,
-        deployId
-      ).catch(reject);
+    for (let subTask of initialTaskStatus[statusText.SUBTASK_KEY]) {
+      spinnies.add(subTask[statusText.SUBTASK_NAME_KEY], {
+        text: `${chalk.bold(subTask[statusText.SUBTASK_NAME_KEY])} #${buildId ||
+          taskId} ${statusText.STATUS_TEXT[statusText.STATES.ENQUEUED]}\n`,
+      });
+    }
+
+    return new Promise((resolve, reject) => {
+      const pollInterval = setInterval(async () => {
+        const taskStatus = await statusFn(accountId, taskName, taskId).catch(
+          reject
+        );
 
-      const { status, subdeployStatuses } = deployStatus;
+        const { status, [statusText.SUBTASK_KEY]: subTaskStatus } = taskStatus;
 
-      if (spinnies.hasActiveSpinners()) {
-        subdeployStatuses.forEach(subdeploy => {
-          if (!spinnies.pick(subdeploy.deployName)) {
-            return;
-          }
+        if (spinnies.hasActiveSpinners()) {
+          subTaskStatus.forEach(subTask => {
+            if (!spinnies.pick(subTask[statusText.SUBTASK_NAME_KEY])) {
+              return;
+            }
 
-          const updatedText = `${chalk.bold(
-            subdeploy.deployName
-          )} #${deployedBuildId} ${
-            PROJECT_DEPLOY_STATUS_TEXT[subdeploy.status]
-          }`;
+            const updatedText = `${chalk.bold(
+              subTask[statusText.SUBTASK_NAME_KEY]
+            )} #${taskId} ${statusText.STATUS_TEXT[subTask.status]}\n`;
+
+            switch (subTask.status) {
+              case statusText.STATES.SUCCESS:
+                spinnies.succeed(subTask[statusText.SUBTASK_NAME_KEY], {
+                  text: updatedText,
+                });
+                break;
+              case statusText.STATES.FAILURE:
+                spinnies.fail(subTask[statusText.SUBTASK_NAME_KEY], {
+                  text: updatedText,
+                });
+                break;
+              default:
+                spinnies.update(subTask[statusText.SUBTASK_NAME_KEY], {
+                  text: updatedText,
+                });
+                break;
+            }
+          });
 
-          switch (subdeploy.status) {
-            case PROJECT_DEPLOY_STATUS.SUCCESS:
-              spinnies.succeed(subdeploy.deployName, {
-                text: updatedText,
-              });
-              break;
-            case PROJECT_DEPLOY_STATUS.FAILURE:
-              spinnies.fail(subdeploy.deployName, {
-                text: updatedText,
+          if (isTaskComplete(taskStatus)) {
+            subTaskStatus.forEach(subTask => {
+              spinnies.remove(subTask[statusText.SUBTASK_NAME_KEY]);
+            });
+
+            if (status === statusText.STATES.SUCCESS) {
+              spinnies.succeed('overallTaskStatus', {
+                text: statusStrings.SUCCESS(taskName),
               });
-              break;
-            default:
-              spinnies.update(subdeploy.deployName, {
-                text: updatedText,
+            } else if (status === statusText.STATES.FAILURE) {
+              spinnies.fail('overallTaskStatus', {
+                text: statusStrings.FAIL(taskName),
               });
-              break;
-          }
-        });
-      }
 
-      if (isBuildComplete(deployStatus)) {
-        clearInterval(pollInterval);
-
-        if (status === PROJECT_DEPLOY_STATUS.SUCCESS) {
-          logger.success(
-            `Your project ${chalk.bold(name)} ${
-              PROJECT_DEPLOY_STATUS_TEXT[status]
-            }.`
-          );
-        } else if (status === PROJECT_DEPLOY_STATUS.FAILURE) {
-          logger.error(
-            `Your project ${chalk.bold(name)} ${
-              PROJECT_DEPLOY_STATUS_TEXT[status]
-            }.`
-          );
-          subdeployStatuses.forEach(subdeploy => {
-            if (subdeploy.status === PROJECT_DEPLOY_STATUS.FAILURE) {
-              logger.error(
-                `${chalk.bold(subdeploy.deployName)} failed to build. ${
-                  subdeploy.errorMessage
-                }.`
+              const failedSubtask = subTaskStatus.filter(
+                subtask => subtask.status === 'FAILURE'
               );
+
+              uiLine();
+              logger.log(
+                `${statusStrings.SUBTASK_FAIL(
+                  buildId || taskId,
+                  failedSubtask.length === 1
+                    ? failedSubtask[0][statusText.SUBTASK_NAME_KEY]
+                    : failedSubtask.length + ' components'
+                )}\n`
+              );
+              logger.log('See below for a summary of errors.');
+              uiLine();
+
+              failedSubtask.forEach(subTask => {
+                logger.log(
+                  `\n--- ${chalk.bold(subTask[statusText.SUBTASK_NAME_KEY])} ${
+                    statusText.STATUS_TEXT[subTask.status]
+                  } with the following error ---`
+                );
+                logger.error(subTask.errorMessage);
+              });
             }
-          });
+
+            clearInterval(pollInterval);
+            resolve(taskStatus);
+          }
         }
-        resolve(deployStatus);
-      }
-    }, POLLING_DELAY);
-  });
+      }, POLLING_DELAY);
+    });
+  };
 };
 
 module.exports = {
   writeProjectConfig,
   getProjectConfig,
-  getOrCreateProjectConfig,
+  createProjectConfig,
   validateProjectConfig,
   showWelcomeMessage,
-  pollBuildStatus,
-  pollDeployStatus,
+  getProjectDetailUrl,
+  pollBuildStatus: makeGetTaskStatus('build'),
+  pollDeployStatus: makeGetTaskStatus('deploy'),
   ensureProjectExists,
 };

package/lib/prompts/projects.js

@@ -1,5 +1,8 @@
 const inquirer = require('inquirer');
 const { PROJECT_TEMPLATE_TYPES } = require('@hubspot/cli-lib/lib/constants');
+const { i18n } = require('@hubspot/cli-lib/lib/lang');
+
+const i18nKey = 'cli.lib.prompts.projects';
 
 const createProjectPrompt = (promptOptions = {}) => {
   const prompt = inquirer.createPromptModule();
@@ -7,16 +10,16 @@ const createProjectPrompt = (promptOptions = {}) => {
     {
       type: 'list',
       name: 'template',
-      message: 'Select a project template to use',
+      message: i18n(`${i18nKey}.selectTemplate`),
       default: PROJECT_TEMPLATE_TYPES.blank,
       choices: Object.keys(PROJECT_TEMPLATE_TYPES),
     },
     {
       name: 'label',
-      message: 'Enter a label for the project',
+      message: i18n(`${i18nKey}.enterLabel`),
       validate(val) {
         if (typeof val !== 'string') {
-          return 'You entered an invalid label. Please try again.';
+          return i18n(`${i18nKey}.errors.invalidLabel`);
         }
         return true;
       },
@@ -24,10 +27,10 @@ const createProjectPrompt = (promptOptions = {}) => {
     },
     {
       name: 'description',
-      message: 'Enter a description for the project',
+      message: i18n(`${i18nKey}.enterDescription`),
       validate(val) {
         if (typeof val !== 'string') {
-          return 'You entered an invalid description. Please try again.';
+          return i18n(`${i18nKey}.errors.invalidDescription`);
         }
         return true;
       },

package/lib/prompts/sandboxes.js

@@ -1,14 +1,17 @@
 const inquirer = require('inquirer');
+const { i18n } = require('@hubspot/cli-lib/lib/lang');
+
+const i18nKey = 'cli.lib.prompts.sandboxes';
 
 const createSandbox = () => {
   const prompt = inquirer.createPromptModule();
   return prompt([
     {
       name: 'name',
-      message: 'Enter a name to use for the sandbox: ',
+      message: i18n(`${i18nKey}.enterName`),
       validate(val) {
         if (typeof val !== 'string') {
-          return 'You entered an invalid name. Please try again.';
+          return i18n(`${i18nKey}.errors.invalidName`);
         }
         return true;
       },