@hubspot/cli 5.0.2-beta.0 → 5.0.2

package/lib/LocalDevManager.js

@@ -2,8 +2,8 @@ const path = require('path');
 const chokidar = require('chokidar');
 const chalk = require('chalk');
 const { i18n } = require('./lang');
+const { handleKeypress } = require('./process');
 const { logger } = require('@hubspot/cli-lib/logger');
-const { handleKeypress } = require('@hubspot/cli-lib/lib/process');
 const {
   getAccountId,
   getConfigDefaultAccount,
@@ -89,7 +89,12 @@ class LocalDevManager {
 
     // The project does not contain any components that support local development
     if (!runnableComponents.length) {
-      logger.error(i18n(`${i18nKey}.noRunnableComponents`));
+      logger.error(
+        i18n(`${i18nKey}.noRunnableComponents`, {
+          projectSourceDir: this.projectSourceDir,
+          command: uiCommandReference('hs project add'),
+        })
+      );
       process.exit(EXIT_CODES.SUCCESS);
     }
 

package/lib/errorHandlers/apiErrors.js

@@ -0,0 +1,352 @@
+const { logger } = require('@hubspot/cli-lib/logger');
+const { getAccountConfig } = require('@hubspot/cli-lib/lib/config');
+const {
+  SCOPE_GROUPS,
+  PERSONAL_ACCESS_KEY_AUTH_METHOD,
+} = require('@hubspot/cli-lib/lib/constants');
+const {
+  fetchScopeData,
+} = require('@hubspot/cli-lib/api/localDevAuth/authenticated');
+const {
+  debugErrorAndContext,
+  logErrorInstance,
+  ErrorContext,
+} = require('./standardErrors');
+const { i18n } = require('../lang');
+
+const i18nKey = 'cli.lib.errorHandlers.apiErrors';
+
+const isApiStatusCodeError = err =>
+  err.name === 'StatusCodeError' ||
+  (err.statusCode >= 100 && err.statusCode < 600);
+
+const isApiUploadValidationError = err =>
+  !!(
+    err.statusCode === 400 &&
+    err.response &&
+    err.response.body &&
+    (err.response.body.message || err.response.body.errors)
+  );
+
+const isMissingScopeError = err =>
+  err.name === 'StatusCodeError' &&
+  err.statusCode === 403 &&
+  err.error &&
+  err.error.category === 'MISSING_SCOPES';
+
+const isGatingError = err =>
+  isSpecifiedError(err, { statusCode: 403, category: 'GATED' });
+
+const isSpecifiedError = (err, { statusCode, category, subCategory } = {}) => {
+  const statusCodeErr = !statusCode || err.statusCode === statusCode;
+  const categoryErr =
+    !category || (err.error && err.error.category === category);
+  const subCategoryErr =
+    !subCategory || (err.error && err.error.subCategory === subCategory);
+
+  return (
+    err.name === 'StatusCodeError' &&
+    statusCodeErr &&
+    categoryErr &&
+    subCategoryErr
+  );
+};
+
+const isSpecifiedHubSpotAuthError = (
+  err,
+  { statusCode, category, subCategory }
+) => {
+  const statusCodeErr = !statusCode || err.statusCode === statusCode;
+  const categoryErr = !category || err.category === category;
+  const subCategoryErr = !subCategory || err.subCategory === subCategory;
+  return (
+    err.name === 'HubSpotAuthError' &&
+    statusCodeErr &&
+    categoryErr &&
+    subCategoryErr
+  );
+};
+
+const parseValidationErrors = (responseBody = {}) => {
+  const errorMessages = [];
+
+  const { errors, message } = responseBody;
+
+  if (message) {
+    errorMessages.push(message);
+  }
+
+  if (errors) {
+    const specificErrors = errors.map(error => {
+      let errorMessage = error.message;
+      if (error.errorTokens && error.errorTokens.line) {
+        errorMessage = `line ${error.errorTokens.line}: ${errorMessage}`;
+      }
+      return errorMessage;
+    });
+    errorMessages.push(...specificErrors);
+  }
+
+  return errorMessages;
+};
+
+class ApiErrorContext extends ErrorContext {
+  constructor(props = {}) {
+    super(props);
+    /** @type {string} */
+    this.request = props.request || '';
+    /** @type {string} */
+    this.payload = props.payload || '';
+    /** @type {string} */
+    this.projectName = props.projectName || '';
+  }
+}
+
+/**
+ * @param {Error}           error
+ * @param {ApiErrorContext} context
+ */
+function logValidationErrors(error, context) {
+  const { response = {} } = error;
+  const validationErrors = parseValidationErrors(response.body);
+  if (validationErrors.length) {
+    validationErrors.forEach(err => {
+      logger.error(err);
+    });
+  }
+  debugErrorAndContext(error, context);
+}
+
+/**
+ * Message segments for API messages.
+ *
+ * @enum {string}
+ */
+const ApiMethodVerbs = {
+  DEFAULT: 'request',
+  DELETE: 'delete',
+  GET: 'request',
+  PATCH: 'update',
+  POST: 'post',
+  PUT: 'update',
+};
+
+/**
+ * Message segments for API messages.
+ *
+ * @enum {string}
+ */
+const ApiMethodPrepositions = {
+  DEFAULT: 'for',
+  DELETE: 'of',
+  GET: 'for',
+  PATCH: 'to',
+  POST: 'to',
+  PUT: 'to',
+};
+
+/**
+ * Logs messages for an error instance resulting from API interaction.
+ *
+ * @param {StatusCodeError} error
+ * @param {ApiErrorContext} context
+ */
+function logApiStatusCodeError(error, context) {
+  const { statusCode } = error;
+  const { method } = error.options || {};
+  const { projectName } = context;
+  const isPutOrPost = method === 'PUT' || method === 'POST';
+  const action = ApiMethodVerbs[method] || ApiMethodVerbs.DEFAULT;
+  const preposition =
+    ApiMethodPrepositions[method] || ApiMethodPrepositions.DEFAULT;
+  let messageDetail = '';
+  {
+    const request = context.request
+      ? `${action} ${preposition} "${context.request}"`
+      : action;
+    messageDetail = `${request} in account ${context.accountId}`;
+  }
+  const errorMessage = [];
+  if (isPutOrPost && context.payload) {
+    errorMessage.push(`Unable to upload "${context.payload}".`);
+  }
+  const isProjectMissingScopeError = isMissingScopeError(error) && projectName;
+  const isProjectGatingError = isGatingError(error) && projectName;
+  switch (statusCode) {
+    case 400:
+      errorMessage.push(i18n(`${i18nKey}.codes.400`, { messageDetail }));
+      break;
+    case 401:
+      errorMessage.push(i18n(`${i18nKey}.codes.401`, { messageDetail }));
+      break;
+    case 403:
+      if (isProjectMissingScopeError) {
+        errorMessage.push(
+          i18n(`${i18nKey}.codes.403MissingScope`, {
+            accountId: context.accountId || '',
+          })
+        );
+      } else if (isProjectGatingError) {
+        errorMessage.push(
+          i18n(`${i18nKey}.codes.403Gating`, {
+            accountId: context.accountId || '',
+          })
+        );
+      } else {
+        errorMessage.push(i18n(`${i18nKey}.codes.403`, { messageDetail }));
+      }
+      break;
+    case 404:
+      if (context.request) {
+        errorMessage.push(
+          i18n(`${i18nKey}.codes.404Request`, {
+            action: action || 'request',
+            request: context.request,
+            account: context.accountId || '',
+          })
+        );
+      } else {
+        errorMessage.push(i18n(`${i18nKey}.codes.404`, { messageDetail }));
+      }
+      break;
+    case 429:
+      errorMessage.push(i18n(`${i18nKey}.codes.429`, { messageDetail }));
+      break;
+    case 503:
+      errorMessage.push(i18n(`${i18nKey}.codes.503`, { messageDetail }));
+      break;
+    default:
+      if (statusCode >= 500 && statusCode < 600) {
+        errorMessage.push(
+          i18n(`${i18nKey}.codes.500Generic`, { messageDetail })
+        );
+      } else if (statusCode >= 400 && statusCode < 500) {
+        i18n(`${i18nKey}.codes.400Generic`, { messageDetail });
+      } else {
+        errorMessage.push(i18n(`${i18nKey}.codes.generic`, { messageDetail }));
+      }
+      break;
+  }
+  if (
+    error.error &&
+    error.error.message &&
+    !isProjectMissingScopeError &&
+    !isProjectGatingError
+  ) {
+    errorMessage.push(error.error.message);
+  }
+  if (error.error && error.error.errors) {
+    error.error.errors.forEach(err => {
+      errorMessage.push('\n- ' + err.message);
+    });
+  }
+  logger.error(errorMessage.join(' '));
+  debugErrorAndContext(error, context);
+}
+
+/**
+ * Logs a message for an error instance resulting from API interaction.
+ *
+ * @param {Error|SystemError|Object} error
+ * @param {ApiErrorContext}          context
+ */
+function logApiErrorInstance(error, context) {
+  // StatusCodeError
+  if (isApiStatusCodeError(error)) {
+    logApiStatusCodeError(error, context);
+    return;
+  }
+  logErrorInstance(error, context);
+}
+
+/**
+ * Logs a message for an error instance resulting from filemapper API upload.
+ *
+ * @param {Error|SystemError|Object} error
+ * @param {ApiErrorContext}          context
+ */
+function logApiUploadErrorInstance(error, context) {
+  if (isApiUploadValidationError(error)) {
+    logValidationErrors(error, context);
+    return;
+  }
+  logApiErrorInstance(error, context);
+}
+
+async function verifyAccessKeyAndUserAccess(accountId, scopeGroup) {
+  const accountConfig = getAccountConfig(accountId);
+  const { authType } = accountConfig;
+  if (authType !== PERSONAL_ACCESS_KEY_AUTH_METHOD.value) {
+    return;
+  }
+
+  let scopesData;
+  try {
+    scopesData = await fetchScopeData(accountId, scopeGroup);
+  } catch (e) {
+    logger.debug(
+      i18n(`${i18nKey}.verifyAccessKeyAndUserAccess.fetchScopeDataError`, {
+        scopeGroup,
+        error: e,
+      })
+    );
+    return;
+  }
+  const { portalScopesInGroup, userScopesInGroup } = scopesData;
+
+  if (!portalScopesInGroup.length) {
+    logger.error(
+      i18n(`${i18nKey}.verifyAccessKeyAndUserAccess.portalMissingScope`)
+    );
+    return;
+  }
+
+  if (!portalScopesInGroup.every(s => userScopesInGroup.includes(s))) {
+    logger.error(
+      i18n(`${i18nKey}.verifyAccessKeyAndUserAccess.userMissingScope`)
+    );
+    return;
+  } else {
+    logger.error(
+      i18n(`${i18nKey}.verifyAccessKeyAndUserAccess.genericMissingScope`)
+    );
+    return;
+  }
+}
+
+/**
+ * Logs a message for an error instance resulting from API interaction
+ * related to serverless function.
+ *
+ * @param {int} accountId
+ * @param {Error|SystemError|Object} error
+ * @param {ApiErrorContext}          context
+ */
+async function logServerlessFunctionApiErrorInstance(
+  accountId,
+  error,
+  context
+) {
+  if (isMissingScopeError(error)) {
+    await verifyAccessKeyAndUserAccess(accountId, SCOPE_GROUPS.functions);
+    return;
+  }
+
+  // StatusCodeError
+  if (isApiStatusCodeError(error)) {
+    logApiStatusCodeError(error, context);
+    return;
+  }
+  logErrorInstance(error, context);
+}
+
+module.exports = {
+  ApiErrorContext,
+  parseValidationErrors,
+  logApiErrorInstance,
+  logApiUploadErrorInstance,
+  logServerlessFunctionApiErrorInstance,
+  isMissingScopeError,
+  isSpecifiedError,
+  isSpecifiedHubSpotAuthError,
+};

package/lib/errorHandlers/fileSystemErrors.js

@@ -0,0 +1,55 @@
+const { logger } = require('@hubspot/cli-lib/logger');
+const {
+  ErrorContext,
+  isSystemError,
+  debugErrorAndContext,
+} = require('./standardErrors');
+const { i18n } = require('../lang');
+
+const i18nKey = 'cli.lib.errorHandlers.fileSystemErrors';
+
+class FileSystemErrorContext extends ErrorContext {
+  constructor(props = {}) {
+    super(props);
+    /** @type {string} */
+    this.filepath = props.filepath || '';
+    /** @type {boolean} */
+    this.read = !!props.read;
+    /** @type {boolean} */
+    this.write = !!props.write;
+  }
+}
+
+/**
+ * Logs a message for an error instance resulting from filesystem interaction.
+ *
+ * @param {Error|SystemError|Object} error
+ * @param {FileSystemErrorContext}   context
+ */
+function logFileSystemErrorInstance(error, context) {
+  let fileAction = '';
+  if (context.read) {
+    fileAction = 'reading from';
+  } else if (context.write) {
+    fileAction = 'writing to';
+  } else {
+    fileAction = 'accessing';
+  }
+  const filepath = context.filepath
+    ? `"${context.filepath}"`
+    : 'a file or folder';
+  const message = [i18n(`${i18nKey}.errorOccurred`, { fileAction, filepath })];
+  // Many `fs` errors will be `SystemError`s
+  if (isSystemError(error)) {
+    message.push(
+      i18n(`${i18nKey}.errorExplanation`, { errorMessage: error.message })
+    );
+  }
+  logger.error(message.join(' '));
+  debugErrorAndContext(error, context);
+}
+
+module.exports = {
+  FileSystemErrorContext,
+  logFileSystemErrorInstance,
+};

package/lib/errorHandlers/standardErrors.js

@@ -0,0 +1,95 @@
+const { HubSpotAuthError } = require('@hubspot/cli-lib/lib/models/Errors');
+const { logger } = require('@hubspot/cli-lib/logger');
+const { i18n } = require('../lang');
+
+const i18nKey = 'cli.lib.errorHandlers.standardErrors';
+
+const isSystemError = err =>
+  err.errno != null && err.code != null && err.syscall != null;
+const isFatalError = err => err instanceof HubSpotAuthError;
+
+// TODO: Make these TS interfaces
+class ErrorContext {
+  constructor(props = {}) {
+    /** @type {number} */
+    this.accountId = props.accountId;
+  }
+}
+
+/**
+ * Logs (debug) the error and context objects.
+ *
+ * @param {SystemError}  error
+ * @param {ErrorContext} context
+ */
+function debugErrorAndContext(error, context) {
+  if (error.name === 'StatusCodeError') {
+    const { statusCode, message, response } = error;
+    logger.debug(
+      i18n(`${i18nKey}.errorOccurred`, {
+        error: {
+          statusCode,
+          message,
+          url: response.request.href,
+          method: response.request.method,
+          response: response.body,
+          headers: response.headers,
+        },
+      })
+    );
+  } else {
+    logger.debug(i18n(`${i18nKey}.errorOccurred`, { error }));
+  }
+  logger.debug(i18n(`${i18nKey}.errorContext`, { context }));
+}
+
+/**
+ * Logs a SystemError
+ * @see {@link https://nodejs.org/api/errors.html#errors_class_systemerror}
+ *
+ * @param {SystemError}  error
+ * @param {ErrorContext} context
+ */
+function logSystemError(error, context) {
+  logger.error(
+    i18n(`${i18nKey}.systemErrorOccurred`, { error: error.message })
+  );
+  debugErrorAndContext(error, context);
+}
+
+/**
+ * Logs a message for an error instance of type not asserted.
+ *
+ * @param {Error|SystemError|Object} error
+ * @param {ErrorContext}             context
+ */
+function logErrorInstance(error, context) {
+  // SystemError
+  if (isSystemError(error)) {
+    logSystemError(error, context);
+    return;
+  }
+  if (error instanceof Error || error.message || error.reason) {
+    // Error or Error subclass
+    const name = error.name || 'Error';
+    const message = [i18n(`${i18nKey}.genericErrorOccurred`, { name })];
+    [(error.message, error.reason)].forEach(msg => {
+      if (msg) {
+        message.push(msg);
+      }
+    });
+    logger.error(message.join(' '));
+  } else {
+    // Unknown errors
+    logger.error(i18n(`${i18nKey}.unknownErrorOccurred`));
+  }
+  debugErrorAndContext(error, context);
+}
+
+module.exports = {
+  debugErrorAndContext,
+  ErrorContext,
+  isFatalError,
+  isSystemError,
+  logErrorInstance,
+};

package/lib/getFunctionArrays.js

@@ -0,0 +1,18 @@
+const moment = require('moment');
+
+const getFunctionArrays = resp => {
+  return resp.objects.map(func => {
+    const { route, method, created, updated, secretNames } = func;
+    return [
+      route,
+      method,
+      secretNames.join(', '),
+      moment(created).format(),
+      moment(updated).format(),
+    ];
+  });
+};
+
+module.exports = {
+  getFunctionArrays,
+};

package/lib/hublValidate.js

@@ -0,0 +1,32 @@
+const { logger } = require('@hubspot/cli-lib/logger');
+
+const getErrorsFromHublValidationObject = validation =>
+  (validation && validation.meta && validation.meta.template_errors) || [];
+
+function printHublValidationError(err) {
+  const { severity, message, lineno, startPosition } = err;
+  const method = severity === 'FATAL' ? 'error' : 'warn';
+  logger[method]('[%d, %d]: %s', lineno, startPosition, message);
+}
+
+function printHublValidationResult({ file, validation }) {
+  let count = 0;
+  const errors = getErrorsFromHublValidationObject(validation);
+  if (!errors.length) {
+    return count;
+  }
+  logger.group(file);
+  errors.forEach(err => {
+    if (err.reason !== 'SYNTAX_ERROR') {
+      return;
+    }
+    ++count;
+    printHublValidationError(err);
+  });
+  logger.groupEnd(file);
+  return count;
+}
+
+module.exports = {
+  printHublValidationResult,
+};

package/lib/oauth.js

@@ -3,7 +3,7 @@ const open = require('open');
 const OAuth2Manager = require('@hubspot/cli-lib/lib/models/OAuth2Manager');
 const { getAccountConfig } = require('@hubspot/cli-lib/lib/config');
 const { addOauthToAccountConfig } = require('@hubspot/cli-lib/oauth');
-const { handleExit } = require('@hubspot/cli-lib/lib/process');
+const { handleExit } = require('./process');
 const { getHubSpotWebsiteOrigin } = require('@hubspot/cli-lib/lib/urls');
 const { logger } = require('@hubspot/cli-lib/logger');
 const { ENVIRONMENTS } = require('@hubspot/cli-lib/lib/constants');

package/lib/process.js

@@ -0,0 +1,42 @@
+const readline = require('readline');
+
+const handleExit = callback => {
+  const terminationSignals = [
+    'beforeExit',
+    'SIGINT',
+    'SIGUSR1',
+    'SIGUSR2',
+    'uncaughtException',
+    'SIGTERM',
+    'SIGHUP',
+  ];
+  terminationSignals.forEach(signal => {
+    process.removeAllListeners(signal);
+
+    process.on(signal, async () => {
+      await callback();
+    });
+  });
+};
+
+const handleKeypress = callback => {
+  readline.createInterface(process.stdin, process.stdout);
+  readline.emitKeypressEvents(process.stdin);
+
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+  }
+
+  process.stdin.removeAllListeners('keypress');
+
+  process.stdin.on('keypress', (str, key) => {
+    if (key) {
+      callback(key);
+    }
+  });
+};
+
+module.exports = {
+  handleExit,
+  handleKeypress,
+};

package/lib/projects.js

@@ -29,10 +29,6 @@ const {
   fetchProject,
   uploadProject,
 } = require('@hubspot/cli-lib/api/dfs');
-const {
-  logApiErrorInstance,
-  ApiErrorContext,
-} = require('@hubspot/cli-lib/errorHandlers');
 const { shouldIgnoreFile } = require('@hubspot/cli-lib/ignoreRules');
 const { getCwd, getAbsoluteFilePath } = require('@hubspot/cli-lib/path');
 const { downloadGitHubRepoContents } = require('@hubspot/cli-lib/github');
@@ -42,9 +38,11 @@ const { uiLine, uiLink, uiAccountDescription } = require('../lib/ui');
 const { i18n } = require('./lang');
 const SpinniesManager = require('./SpinniesManager');
 const {
+  logApiErrorInstance,
+  ApiErrorContext,
   isSpecifiedError,
   isSpecifiedHubSpotAuthError,
-} = require('@hubspot/cli-lib/errorHandlers/apiErrors');
+} = require('./errorHandlers/apiErrors');
 const { HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH } = require('./constants');
 
 const i18nKey = 'cli.lib.projects';
@@ -522,9 +520,27 @@ const handleProjectUpload = async (
 
   archive.pipe(output);
 
-  archive.directory(srcDir, false, file =>
-    shouldIgnoreFile(file.name, true) ? false : file
-  );
+  let loggedIgnoredNodeModule = false;
+
+  archive.directory(srcDir, false, file => {
+    const ignored = shouldIgnoreFile(file.name, true);
+    if (ignored) {
+      const isNodeModule = file.name.includes('node_modules');
+
+      if (!isNodeModule || !loggedIgnoredNodeModule) {
+        logger.debug(
+          i18n(`${i18nKey}.handleProjectUpload.fileFiltered`, {
+            filename: file.name,
+          })
+        );
+      }
+
+      if (isNodeModule && !loggedIgnoredNodeModule) {
+        loggedIgnoredNodeModule = true;
+      }
+    }
+    return ignored ? false : file;
+  });
 
   archive.finalize();