@hubspot/cli 3.0.10-beta.6 → 3.0.10

package/commands/project/logs.js

@@ -1,48 +1,51 @@
 const Spinnies = require('spinnies');
+const { getCwd } = require('@hubspot/cli-lib/path');
 const {
   addAccountOptions,
   addConfigOptions,
-  setLogLevel,
   getAccountId,
   addUseEnvironmentOptions,
 } = require('../../lib/commonOpts');
 const { trackCommandUsage } = require('../../lib/usageTracking');
-const { logDebugInfo } = require('../../lib/debugInfo');
-const {
-  loadConfig,
-  validateConfig,
-  checkAndWarnGitInclusion,
-} = require('@hubspot/cli-lib');
 const { logger } = require('@hubspot/cli-lib/logger');
 const { outputLogs } = require('@hubspot/cli-lib/lib/logs');
 const {
   getProjectAppFunctionLogs,
   getLatestProjectAppFunctionLog,
 } = require('@hubspot/cli-lib/api/functions');
-const { validateAccount } = require('../../lib/validation');
+const {
+  getFunctionLogs,
+  getLatestFunctionLog,
+} = require('@hubspot/cli-lib/api/results');
+const { getProjectConfig } = require('../../lib/projects');
+const { loadAndValidateOptions } = require('../../lib/validation');
 const { tailLogs } = require('../../lib/serverlessLogs');
+const { uiAccountDescription } = require('../../lib/ui');
+const { i18n } = require('@hubspot/cli-lib/lib/lang');
 
-const loadAndValidateOptions = async options => {
-  setLogLevel(options);
-  logDebugInfo(options);
-  const { config: configPath } = options;
-  loadConfig(configPath, options);
-  checkAndWarnGitInclusion();
-
-  if (!(validateConfig() && (await validateAccount(options)))) {
-    process.exit(1);
-  }
-};
+const i18nKey = 'cli.commands.project.subcommands.logs';
+const { EXIT_CODES } = require('../../lib/enums/exitCodes');
 
 const handleLogsError = (e, accountId, projectName, appPath, functionName) => {
   if (e.statusCode === 404) {
     logger.error(
-      `No logs were found for the function name '${functionName}' in the app path '${appPath}' within the project '${projectName}' in account ${accountId}.`
+      appPath
+        ? i18n(`${i18nKey}.errors.noAppFunctionLogs`, {
+            accountId,
+            appPath,
+            functionName,
+            projectName,
+          })
+        : i18n(`${i18nKey}.errors.noEndpointLogs`, {
+            accountId,
+            functionName,
+            projectName,
+          })
     );
   }
 };
 
-const appFunctionLog = async (accountId, options) => {
+const functionLog = async (accountId, options) => {
   const {
     latest,
     follow,
@@ -54,28 +57,43 @@ const appFunctionLog = async (accountId, options) => {
 
   let logsResp;
 
+  const tailCall = async after => {
+    try {
+      return appPath
+        ? getProjectAppFunctionLogs(
+            accountId,
+            functionName,
+            projectName,
+            appPath,
+            {
+              after,
+            }
+          )
+        : getFunctionLogs(accountId, functionName, { after });
+    } catch (e) {
+      handleLogsError(e, accountId, projectName, appPath, functionName);
+    }
+  };
+  const fetchLatest = async () => {
+    return appPath
+      ? getLatestProjectAppFunctionLog(
+          accountId,
+          functionName,
+          projectName,
+          appPath
+        )
+      : getLatestFunctionLog(accountId, functionName);
+  };
+
   if (follow) {
     const spinnies = new Spinnies();
 
     spinnies.add('tailLogs', {
-      text: `Waiting for log entries for '${functionName}' on account '${accountId}'.\n`,
+      text: i18n(`${i18nKey}.loading`, {
+        functionName,
+        accountId: uiAccountDescription(accountId),
+      }),
     });
-    const tailCall = after =>
-      getProjectAppFunctionLogs(accountId, functionName, projectName, appPath, {
-        after,
-      });
-    const fetchLatest = () => {
-      try {
-        return getLatestProjectAppFunctionLog(
-          accountId,
-          functionName,
-          projectName,
-          appPath
-        );
-      } catch (e) {
-        handleLogsError(e, accountId, projectName, appPath, functionName);
-      }
-    };
 
     await tailLogs({
       accountId,
@@ -86,24 +104,13 @@ const appFunctionLog = async (accountId, options) => {
     });
   } else if (latest) {
     try {
-      logsResp = await getLatestProjectAppFunctionLog(
-        accountId,
-        functionName,
-        projectName,
-        appPath
-      );
+      logsResp = await fetchLatest();
     } catch (e) {
       handleLogsError(e, accountId, projectName, appPath, functionName);
     }
   } else {
     try {
-      logsResp = await getProjectAppFunctionLogs(
-        accountId,
-        functionName,
-        projectName,
-        appPath,
-        {}
-      );
+      logsResp = await tailCall();
     } catch (e) {
       handleLogsError(e, accountId, projectName, appPath, functionName);
     }
@@ -114,68 +121,69 @@ const appFunctionLog = async (accountId, options) => {
   }
 };
 
-exports.command = 'logs [functionName]';
-exports.describe = 'get logs for a function within a project';
+exports.command = 'logs';
+exports.describe = i18n(`${i18nKey}.describe`);
 
 exports.handler = async options => {
-  loadAndValidateOptions(options);
+  await loadAndValidateOptions(options);
 
-  const { latest, functionName, projectName, appPath } = options;
+  const { latest, functionName } = options;
+  let projectName = options.projectName;
 
   if (!functionName) {
-    logger.error('You must pass a function name to retrieve logs for.');
-    process.exit(0);
+    logger.error(i18n(`${i18nKey}.errors.functionNameRequired`));
+    process.exit(EXIT_CODES.ERROR);
   } else if (!projectName) {
-    logger.error(
-      'You must specify a project name using the --projectName argument.'
-    );
-    process.exit(0);
-  } else if (!appPath) {
-    logger.error('You must specify an app path using the --appPath argument.');
-    process.exit(0);
+    const { projectConfig } = await getProjectConfig(getCwd());
+    if (projectConfig && projectConfig.name) {
+      projectName = projectConfig.name;
+    } else {
+      logger.error(i18n(`${i18nKey}.errors.projectNameRequired`));
+      process.exit(EXIT_CODES.ERROR);
+    }
   }
 
   const accountId = getAccountId(options);
 
   trackCommandUsage('project-logs', { latest }, accountId);
 
-  appFunctionLog(accountId, options);
+  functionLog(accountId, { ...options, projectName });
 };
 
 exports.builder = yargs => {
-  yargs.positional('functionName', {
-    describe: 'Serverless function name',
-    type: 'string',
-  });
   yargs
     .options({
+      functionName: {
+        alias: 'function',
+        describe: i18n(`${i18nKey}.positionals.functionName.describe`),
+        type: 'string',
+        demandOption: true,
+      },
       appPath: {
-        describe: 'path to the app',
+        describe: i18n(`${i18nKey}.options.appPath.describe`),
         type: 'string',
-        hidden: true,
       },
       projectName: {
-        describe: 'name of the project',
+        describe: i18n(`${i18nKey}.options.projectName.describe`),
         type: 'string',
-        hidden: true,
       },
       latest: {
         alias: 'l',
-        describe: 'retrieve most recent log only',
+        describe: i18n(`${i18nKey}.options.latest.describe`),
         type: 'boolean',
       },
       compact: {
-        describe: 'output compact logs',
+        describe: i18n(`${i18nKey}.options.compact.describe`),
         type: 'boolean',
       },
       follow: {
         alias: ['t', 'tail', 'f'],
-        describe: 'follow logs',
+        describe: i18n(`${i18nKey}.options.follow.describe`),
         type: 'boolean',
       },
       limit: {
         alias: ['limit', 'n', 'max-count'],
-        describe: 'limit the number of logs to output',
+        describe: i18n(`${i18nKey}.options.limit.describe`),
         type: 'number',
       },
     })
@@ -183,8 +191,8 @@ exports.builder = yargs => {
 
   yargs.example([
     [
-      '$0 project logs my-function --appName="app" --projectName="my-project"',
-      'Get 5 most recent logs for function named "my-function" within the app named "app" within the project named "my-project"',
+      '$0 project logs --function=my-function --appPath="app" --projectName="my-project"',
+      i18n(`${i18nKey}.examples.default`),
     ],
   ]);
 

package/commands/project/upload.js

@@ -7,26 +7,19 @@ const Spinnies = require('spinnies');
 const {
   addAccountOptions,
   addConfigOptions,
-  setLogLevel,
   getAccountId,
   addUseEnvironmentOptions,
 } = require('../../lib/commonOpts');
 const { trackCommandUsage } = require('../../lib/usageTracking');
-const { logDebugInfo } = require('../../lib/debugInfo');
-const {
-  loadConfig,
-  validateConfig,
-  checkAndWarnGitInclusion,
-} = require('@hubspot/cli-lib');
 const {
   logApiErrorInstance,
   ApiErrorContext,
 } = require('@hubspot/cli-lib/errorHandlers');
+const { uiLine, uiAccountDescription } = require('../../lib/ui');
 const { logger } = require('@hubspot/cli-lib/logger');
 const { uploadProject } = require('@hubspot/cli-lib/api/dfs');
 const { shouldIgnoreFile } = require('@hubspot/cli-lib/ignoreRules');
-const { getCwd } = require('@hubspot/cli-lib/path');
-const { validateAccount } = require('../../lib/validation');
+const { loadAndValidateOptions } = require('../../lib/validation');
 const {
   getProjectConfig,
   validateProjectConfig,
@@ -34,31 +27,25 @@ const {
   ensureProjectExists,
   pollDeployStatus,
 } = require('../../lib/projects');
+const { i18n } = require('@hubspot/cli-lib/lib/lang');
 
-const loadAndValidateOptions = async options => {
-  setLogLevel(options);
-  logDebugInfo(options);
-  const { config: configPath } = options;
-  loadConfig(configPath, options);
-  checkAndWarnGitInclusion();
-
-  if (!(validateConfig() && (await validateAccount(options)))) {
-    process.exit(1);
-  }
-};
+const i18nKey = 'cli.commands.project.subcommands.upload';
+const { EXIT_CODES } = require('../../lib/enums/exitCodes');
 
 exports.command = 'upload [path]';
-exports.describe = false;
+exports.describe = i18n(`${i18nKey}.describe`);
 
 const uploadProjectFiles = async (accountId, projectName, filePath) => {
   const spinnies = new Spinnies({
     succeedColor: 'white',
   });
+  const accountIdentifier = uiAccountDescription(accountId);
 
   spinnies.add('upload', {
-    text: `Uploading ${chalk.bold(projectName)} project files to ${chalk.bold(
-      accountId
-    )}`,
+    text: i18n(`${i18nKey}.loading.upload.add`, {
+      accountIdentifier,
+      projectName,
+    }),
   });
 
   let buildId;
@@ -69,19 +56,24 @@ const uploadProjectFiles = async (accountId, projectName, filePath) => {
     buildId = upload.buildId;
 
     spinnies.succeed('upload', {
-      text: `Uploaded ${chalk.bold(projectName)} project files to ${chalk.bold(
-        accountId
-      )}`,
+      text: i18n(`${i18nKey}.loading.upload.succeed`, {
+        accountIdentifier,
+        projectName,
+      }),
     });
 
     logger.debug(
-      `Project "${projectName}" uploaded and build #${buildId} created`
+      i18n(`${i18nKey}.debug.buildCreated`, {
+        buildId,
+        projectName,
+      })
     );
   } catch (err) {
     spinnies.fail('upload', {
-      text: `Failed to upload ${chalk.bold(
-        projectName
-      )} project files to ${chalk.bold(accountId)}`,
+      text: i18n(`${i18nKey}.loading.upload.fail`, {
+        accountIdentifier,
+        projectName,
+      }),
     });
 
     logApiErrorInstance(
@@ -91,24 +83,21 @@ const uploadProjectFiles = async (accountId, projectName, filePath) => {
         projectName,
       })
     );
-    process.exit(1);
+    process.exit(EXIT_CODES.ERROR);
   }
 
   return { buildId };
 };
 
 exports.handler = async options => {
-  loadAndValidateOptions(options);
+  await loadAndValidateOptions(options);
 
   const { forceCreate, path: projectPath } = options;
   const accountId = getAccountId(options);
 
   trackCommandUsage('project-upload', { projectPath }, accountId);
 
-  const projectDir = projectPath
-    ? path.resolve(getCwd(), projectPath)
-    : getCwd();
-  const projectConfig = await getProjectConfig(projectDir);
+  const { projectConfig, projectDir } = await getProjectConfig(projectPath);
 
   validateProjectConfig(projectConfig, projectDir);
 
@@ -116,13 +105,22 @@ exports.handler = async options => {
 
   const tempFile = tmp.fileSync({ postfix: '.zip' });
 
-  logger.debug(`Compressing build files to '${tempFile.name}'`);
+  logger.debug(
+    i18n(`${i18nKey}.debug.compressing`, {
+      path: tempFile.name,
+    })
+  );
 
   const output = fs.createWriteStream(tempFile.name);
   const archive = archiver('zip');
 
   output.on('close', async function() {
-    logger.debug(`Project files compressed: ${archive.pointer()} bytes`);
+    let exitCode = EXIT_CODES.SUCCESS;
+    logger.debug(
+      i18n(`${i18nKey}.debug.compressed`, {
+        byteCount: archive.pointer(),
+      })
+    );
 
     const { buildId } = await uploadProjectFiles(
       accountId,
@@ -134,61 +132,57 @@ exports.handler = async options => {
       isAutoDeployEnabled,
       deployStatusTaskLocator,
       status,
-      subbuildStatuses,
     } = await pollBuildStatus(accountId, projectConfig.name, buildId);
 
     if (status === 'FAILURE') {
-      const failedSubbuilds = subbuildStatuses.filter(
-        subbuild => subbuild.status === 'FAILURE'
-      );
-
-      logger.log('-'.repeat(50));
-      logger.log(
-        `Build #${buildId} failed because there was a problem\nbuilding ${
-          failedSubbuilds.length === 1
-            ? failedSubbuilds[0].buildName
-            : failedSubbuilds.length + ' components'
-        }\n`
-      );
-      logger.log('See below for a summary of errors.');
-      logger.log('-'.repeat(50));
-
-      failedSubbuilds.forEach(subbuild => {
-        logger.log(
-          `\n--- ${subbuild.buildName} failed to build with the following error ---`
-        );
-        logger.error(subbuild.errorMessage);
-      });
-
+      exitCode = EXIT_CODES.ERROR;
       return;
-    }
-
-    if (isAutoDeployEnabled && deployStatusTaskLocator) {
+    } else if (isAutoDeployEnabled && deployStatusTaskLocator) {
       logger.log(
-        `Build #${buildId} succeeded. ${chalk.bold(
-          'Automatically deploying'
-        )} to ${accountId}`
+        i18n(`${i18nKey}.logs.buildSucceededAutomaticallyDeploying`, {
+          accountIdentifier: uiAccountDescription(accountId),
+          buildId,
+        })
       );
-      await pollDeployStatus(
+      const { status } = await pollDeployStatus(
         accountId,
         projectConfig.name,
         deployStatusTaskLocator.id,
         buildId
       );
+      if (status === 'FAILURE') {
+        exitCode = EXIT_CODES.ERROR;
+      }
     } else {
-      logger.log('-'.repeat(50));
-      logger.log(chalk.bold(`Build #${buildId} succeeded\n`));
-      logger.log('🚀 Ready to take your project live?');
-      logger.log(`Run \`${chalk.hex('f5c26b')('hs project deploy')}\``);
-      logger.log('-'.repeat(50));
+      uiLine();
+      logger.log(
+        chalk.bold(
+          i18n(`${i18nKey}.logs.buildSucceeded`, {
+            buildId,
+          })
+        )
+      );
+      logger.log(i18n(`${i18nKey}.logs.readyToGoLive`));
+      logger.log(
+        i18n(`${i18nKey}.logs.runCommand`, {
+          command: chalk.hex('f5c26b')('hs project deploy'),
+        })
+      );
+      uiLine();
     }
 
     try {
       tempFile.removeCallback();
-      logger.debug(`Cleaned up temporary file ${tempFile.name}`);
+      logger.debug(
+        i18n(`${i18nKey}.debug.cleanedUpTempFile`, {
+          path: tempFile.name,
+        })
+      );
     } catch (e) {
       logger.error(e);
     }
+
+    process.exit(exitCode);
   });
 
   archive.on('error', function(err) {
@@ -208,17 +202,19 @@ exports.handler = async options => {
 
 exports.builder = yargs => {
   yargs.positional('path', {
-    describe: 'Path to a project folder',
+    describe: i18n(`${i18nKey}.positionals.path.describe`),
     type: 'string',
   });
 
   yargs.option('forceCreate', {
-    describe: 'Automatically create project if it does not exist',
+    describe: i18n(`${i18nKey}.options.forceCreate.describe`),
     type: 'boolean',
     default: false,
   });
 
-  yargs.example([['$0 project upload myProjectFolder', 'Upload a project']]);
+  yargs.example([
+    ['$0 project upload myProjectFolder', i18n(`${i18nKey}.examples.default`)],
+  ]);
 
   addConfigOptions(yargs, true);
   addAccountOptions(yargs, true);

package/commands/project/watch.js

@@ -0,0 +1,103 @@
+const { i18n } = require('@hubspot/cli-lib/lib/lang');
+const { createWatcher } = require('@hubspot/cli-lib/projectsWatch');
+const { cancelStagedBuild } = require('@hubspot/cli-lib/api/dfs');
+const {
+  logApiErrorInstance,
+  ApiErrorContext,
+} = require('@hubspot/cli-lib/errorHandlers');
+const { logger } = require('@hubspot/cli-lib/logger');
+const {
+  addAccountOptions,
+  addConfigOptions,
+  getAccountId,
+  addUseEnvironmentOptions,
+} = require('../../lib/commonOpts');
+const { trackCommandUsage } = require('../../lib/usageTracking');
+const {
+  getProjectConfig,
+  validateProjectConfig,
+  pollBuildStatus,
+  pollDeployStatus,
+} = require('../../lib/projects');
+const { loadAndValidateOptions } = require('../../lib/validation');
+const { EXIT_CODES } = require('../../lib/enums/exitCodes');
+
+const i18nKey = 'cli.commands.project.subcommands.watch';
+
+exports.command = 'watch [path]';
+exports.describe = i18n(`${i18nKey}.describe`);
+
+const handleBuildStatus = async (accountId, projectName, buildId) => {
+  const {
+    isAutoDeployEnabled,
+    deployStatusTaskLocator,
+  } = await pollBuildStatus(accountId, projectName, buildId);
+
+  if (isAutoDeployEnabled && deployStatusTaskLocator) {
+    await pollDeployStatus(
+      accountId,
+      projectName,
+      deployStatusTaskLocator.id,
+      buildId
+    );
+  }
+};
+
+const handleSigInt = (accountId, projectName, currentBuildId) => {
+  process.removeAllListeners('SIGINT');
+  process.on('SIGINT', async () => {
+    if (currentBuildId) {
+      try {
+        await cancelStagedBuild(accountId, projectName);
+        logger.debug(i18n(`${i18nKey}.debug.buildCancelled`));
+        process.exit(EXIT_CODES.SUCCESS);
+      } catch (err) {
+        logApiErrorInstance(
+          err,
+          new ApiErrorContext({ accountId, projectName: projectName })
+        );
+        process.exit(EXIT_CODES.ERROR);
+      }
+    } else {
+      process.exit(EXIT_CODES.SUCCESS);
+    }
+  });
+};
+
+exports.handler = async options => {
+  await loadAndValidateOptions(options);
+
+  const { path: projectPath } = options;
+  const accountId = getAccountId(options);
+
+  trackCommandUsage('project-watch', { projectPath }, accountId);
+
+  const { projectConfig, projectDir } = await getProjectConfig(projectPath);
+
+  validateProjectConfig(projectConfig, projectDir);
+
+  await createWatcher(
+    accountId,
+    projectConfig,
+    projectDir,
+    handleBuildStatus,
+    handleSigInt
+  );
+};
+
+exports.builder = yargs => {
+  yargs.positional('path', {
+    describe: i18n(`${i18nKey}.describe`),
+    type: 'string',
+  });
+
+  yargs.example([
+    ['$0 project watch myProjectFolder', i18n(`${i18nKey}.examples.default`)],
+  ]);
+
+  addConfigOptions(yargs, true);
+  addAccountOptions(yargs, true);
+  addUseEnvironmentOptions(yargs, true);
+
+  return yargs;
+};

package/commands/project.js

@@ -1,18 +1,15 @@
-const {
-  addConfigOptions,
-  addAccountOptions,
-  addOverwriteOptions,
-} = require('../lib/commonOpts');
+const { addConfigOptions, addAccountOptions } = require('../lib/commonOpts');
 const deploy = require('./project/deploy');
 const create = require('./project/create');
 const upload = require('./project/upload');
+const listBuilds = require('./project/listBuilds');
 const logs = require('./project/logs');
+const watch = require('./project/watch');
 
 exports.command = 'project';
 exports.describe = false; //'Commands for working with projects';
 
 exports.builder = yargs => {
-  addOverwriteOptions(yargs, true);
   addConfigOptions(yargs, true);
   addAccountOptions(yargs, true);
 
@@ -20,6 +17,8 @@ exports.builder = yargs => {
   yargs.command(deploy).demandCommand(1, '');
   yargs.command(create).demandCommand(0, '');
   yargs.command(upload).demandCommand(0, '');
+  yargs.command(watch).demandCommand(0, '');
+  yargs.command(listBuilds).demandCommand(0, '');
   yargs.command(logs).demandCommand(1, '');
 
   return yargs;