@hubspot/cli 5.4.0 → 6.0.0

package/lib/dependencyManagement.js

@@ -0,0 +1,157 @@
+const { logger } = require('@hubspot/local-dev-lib/logger');
+const { getProjectConfig } = require('./projects');
+const { exec: execAsync } = require('child_process');
+const { walk } = require('@hubspot/local-dev-lib/fs');
+const path = require('path');
+const { uiLink } = require('./ui');
+const util = require('util');
+const { i18n } = require('./lang');
+const SpinniesManager = require('./ui/SpinniesManager');
+const fs = require('fs');
+
+const DEFAULT_PACKAGE_MANAGER = 'npm';
+
+const i18nKey = `commands.project.subcommands.installDeps`;
+
+class NoPackageJsonFilesError extends Error {
+  constructor(projectName) {
+    super(
+      i18n(`${i18nKey}.noPackageJsonInProject`, {
+        projectName,
+        link: uiLink(
+          'Learn how to create a project from scratch.',
+          'https://developers.hubspot.com/beta-docs/guides/crm/intro/create-a-project'
+        ),
+      })
+    );
+  }
+}
+
+async function isGloballyInstalled(command) {
+  const exec = util.promisify(execAsync);
+  try {
+    await exec(`${command} --version`);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+async function installPackages({ packages, installLocations }) {
+  const installDirs =
+    installLocations || (await getProjectPackageJsonLocations());
+  await Promise.all(
+    installDirs.map(async dir => {
+      await installPackagesInDirectory(packages, dir);
+    })
+  );
+}
+
+async function installPackagesInDirectory(packages, directory) {
+  const spinner = `installingDependencies-${directory}`;
+  const relativeDir = path.relative(process.cwd(), directory);
+  SpinniesManager.init();
+  SpinniesManager.add(spinner, {
+    text:
+      packages && packages.length
+        ? i18n(`${i18nKey}.addingDependenciesToLocation`, {
+            dependencies: `[${packages.join(', ')}]`,
+            directory: relativeDir,
+          })
+        : i18n(`${i18nKey}.installingDependencies`, {
+            directory: relativeDir,
+          }),
+  });
+  let installCommand = `${DEFAULT_PACKAGE_MANAGER} --prefix=${directory} install`;
+
+  if (packages) {
+    installCommand = `${installCommand} ${packages.join(' ')}`;
+  }
+
+  logger.debug(`Running ${installCommand}`);
+  try {
+    const exec = util.promisify(execAsync);
+    await exec(installCommand);
+    SpinniesManager.succeed(spinner, {
+      text: i18n(`${i18nKey}.installationSuccessful`, {
+        directory: relativeDir,
+      }),
+    });
+  } catch (e) {
+    SpinniesManager.fail(spinner, {
+      text: i18n(`${i18nKey}.installingDependenciesFailed`, {
+        directory: relativeDir,
+      }),
+    });
+    throw new Error(
+      i18n(`${i18nKey}.installingDependenciesFailed`, {
+        directory: relativeDir,
+      }),
+      {
+        cause: e,
+      }
+    );
+  }
+}
+
+async function getProjectPackageJsonLocations() {
+  const projectConfig = await getProjectConfig();
+
+  if (
+    !projectConfig ||
+    !projectConfig.projectDir ||
+    !projectConfig.projectConfig
+  ) {
+    throw new Error(i18n(`${i18nKey}.noProjectConfig`));
+  }
+
+  const {
+    projectDir,
+    projectConfig: { srcDir, name },
+  } = projectConfig;
+
+  if (!(await isGloballyInstalled(DEFAULT_PACKAGE_MANAGER))) {
+    throw new Error(
+      i18n(`${i18nKey}.packageManagerNotInstalled`, {
+        packageManager: DEFAULT_PACKAGE_MANAGER,
+        link: uiLink(
+          DEFAULT_PACKAGE_MANAGER,
+          'https://docs.npmjs.com/downloading-and-installing-node-js-and-npm'
+        ),
+      })
+    );
+  }
+
+  if (
+    !fs.existsSync(projectConfig.projectDir) ||
+    !fs.existsSync(path.join(projectDir, srcDir))
+  ) {
+    throw new NoPackageJsonFilesError(name);
+  }
+
+  const packageJsonFiles = (await walk(path.join(projectDir, srcDir))).filter(
+    file =>
+      file.includes('package.json') &&
+      !file.includes('node_modules') &&
+      !file.includes('.vite')
+  );
+
+  if (packageJsonFiles.length === 0) {
+    throw new NoPackageJsonFilesError(name);
+  }
+
+  const packageParentDirs = [];
+  packageJsonFiles.forEach(packageJsonFile => {
+    const parentDir = path.dirname(packageJsonFile);
+    packageParentDirs.push(parentDir);
+  });
+
+  return packageParentDirs;
+}
+
+module.exports = {
+  isGloballyInstalled,
+  installPackages,
+  DEFAULT_PACKAGE_MANAGER,
+  getProjectPackageJsonLocations,
+};

package/lib/errorHandlers/apiErrors.js

@@ -28,8 +28,6 @@ class ApiErrorContext extends ErrorContext {
     this.request = props.request || '';
     /** @type {string} */
     this.payload = props.payload || '';
-    /** @type {string} */
-    this.projectName = props.projectName || '';
   }
 }
 
@@ -54,7 +52,7 @@ function logValidationErrors(error, context) {
  */
 function logApiErrorInstance(error, context) {
   if (error.isAxiosError) {
-    if (overrideErrors(error)) return;
+    if (overrideErrors(error, context)) return;
     const errorWithContext = getAxiosErrorWithContext(error, context);
     logger.error(errorWithContext.message);
     return;

package/lib/errorHandlers/overrideErrors.js

@@ -1,38 +1,43 @@
-const { isSpecifiedError } = require('@hubspot/local-dev-lib/errors/apiErrors');
+const {
+  isSpecifiedError,
+  isMissingScopeError,
+} = require('@hubspot/local-dev-lib/errors/apiErrors');
 const { logger } = require('@hubspot/local-dev-lib/logger');
-
 const { PLATFORM_VERSION_ERROR_TYPES } = require('../constants');
 const { i18n } = require('../lang');
-const { uiLine, uiLink } = require('../ui');
+const {
+  uiAccountDescription,
+  uiLine,
+  uiLink,
+  uiCommandReference,
+} = require('../ui');
 
 const i18nKey = 'lib.errorHandlers.overrideErrors';
 
-function createPlatformVersionError(subCategory, errData) {
-  const docsLink = uiLink(
-    i18n(`${i18nKey}.platformVersionErrors.docsLink`),
-    'https://developers.hubspot.com/docs/platform/platform-versioning'
-  );
-
-  const platformVersionKey = {
-    [PLATFORM_VERSION_ERROR_TYPES.PLATFORM_VERSION_NOT_SPECIFIED]:
-      'unspecified platformVersion',
-    [PLATFORM_VERSION_ERROR_TYPES.PLATFORM_VERSION_RETIRED]:
-      errData.context.RETIRED_PLATFORM_VERSION,
-    [PLATFORM_VERSION_ERROR_TYPES.PLATFORM_VERSION_SPECIFIED_DOES_NOT_EXIST]:
-      errData.context.PLATFORM_VERSION,
-  };
+function createPlatformVersionError(err, subCategory) {
+  let translationKey = 'unspecifiedPlatformVersion';
+  let platformVersion = 'unspecified platformVersion';
+  const errorContext =
+    err.response && err.response.data && err.response.data.context;
 
-  const errorTypeToTranslationKey = {
-    [PLATFORM_VERSION_ERROR_TYPES.PLATFORM_VERSION_NOT_SPECIFIED]:
-      'unspecifiedPlatformVersion',
-    [PLATFORM_VERSION_ERROR_TYPES.PLATFORM_VERSION_RETIRED]:
-      'platformVersionRetired',
-    [PLATFORM_VERSION_ERROR_TYPES.PLATFORM_VERSION_SPECIFIED_DOES_NOT_EXIST]:
-      'nonExistentPlatformVersion',
-  };
-
-  const platformVersion = platformVersionKey[subCategory] || '';
-  const translationKey = errorTypeToTranslationKey[subCategory];
+  switch (subCategory) {
+    case [PLATFORM_VERSION_ERROR_TYPES.PLATFORM_VERSION_RETIRED]:
+      translationKey = 'platformVersionRetired';
+      if (errorContext && errorContext[subCategory]) {
+        platformVersion = errorContext[subCategory];
+      }
+      break;
+    case [
+      PLATFORM_VERSION_ERROR_TYPES.PLATFORM_VERSION_SPECIFIED_DOES_NOT_EXIST,
+    ]:
+      translationKey = 'nonExistentPlatformVersion';
+      if (errorContext && errorContext[subCategory]) {
+        platformVersion = errorContext[subCategory];
+      }
+      break;
+    default:
+      break;
+  }
 
   uiLine();
   logger.error(i18n(`${i18nKey}.platformVersionErrors.header`));
@@ -44,21 +49,37 @@ function createPlatformVersionError(subCategory, errData) {
   logger.log(i18n(`${i18nKey}.platformVersionErrors.updateProject`));
   logger.log(
     i18n(`${i18nKey}.platformVersionErrors.betaLink`, {
-      docsLink,
+      docsLink: uiLink(
+        i18n(`${i18nKey}.platformVersionErrors.docsLink`),
+        'https://developers.hubspot.com/docs/platform/platform-versioning'
+      ),
     })
   );
   uiLine();
 }
 
-function overrideErrors(err) {
+function overrideErrors(err, context) {
+  if (isMissingScopeError(err)) {
+    logger.error(
+      i18n(`${i18nKey}.missingScopeError`, {
+        accountName: context.accountId
+          ? uiAccountDescription(context.accountId)
+          : '',
+        request: context.request || 'request',
+        authCommand: uiCommandReference('hs auth'),
+      })
+    );
+    return true;
+  }
+
   if (
     isSpecifiedError(err, {
       subCategory: PLATFORM_VERSION_ERROR_TYPES.PLATFORM_VERSION_NOT_SPECIFIED,
     })
   ) {
     createPlatformVersionError(
-      PLATFORM_VERSION_ERROR_TYPES.PLATFORM_VERSION_NOT_SPECIFIED,
-      err.response.data
+      err,
+      PLATFORM_VERSION_ERROR_TYPES.PLATFORM_VERSION_NOT_SPECIFIED
     );
     return true;
   }
@@ -69,8 +90,8 @@ function overrideErrors(err) {
     })
   ) {
     createPlatformVersionError(
-      PLATFORM_VERSION_ERROR_TYPES.PLATFORM_VERSION_RETIRED,
-      err.response.data
+      err,
+      PLATFORM_VERSION_ERROR_TYPES.PLATFORM_VERSION_RETIRED
     );
     return true;
   }
@@ -82,8 +103,8 @@ function overrideErrors(err) {
     })
   ) {
     createPlatformVersionError(
-      PLATFORM_VERSION_ERROR_TYPES.PLATFORM_VERSION_SPECIFIED_DOES_NOT_EXIST,
-      err.response.data
+      err,
+      PLATFORM_VERSION_ERROR_TYPES.PLATFORM_VERSION_SPECIFIED_DOES_NOT_EXIST
     );
     return true;
   }

package/lib/localDev.js

@@ -129,13 +129,6 @@ const suggestRecommendedNestedAccount = async (
         `${i18nKey}.validateAccountOption.publicAppNonDeveloperTestAccountWarning`
       )
     );
-  } else if (isAppDeveloperAccount(accountConfig)) {
-    logger.error(
-      i18n(
-        `${i18nKey}.validateAccountOption.privateAppInAppDeveloperAccountError`
-      )
-    );
-    process.exit(EXIT_CODES.ERROR);
   } else {
     logger.log(i18n(`${i18nKey}.validateAccountOption.nonSandboxWarning`));
   }
@@ -202,6 +195,7 @@ const createSandboxForLocalDev = async (accountId, accountConfig, env) => {
       accountConfig,
       sandboxAccountConfig
     );
+    // For v1 sandboxes, keep sync here. Once we migrate to v2, this will be handled by BE automatically
     await syncSandbox({
       accountConfig: sandboxAccountConfig,
       parentAccountConfig: accountConfig,

package/lib/projectLogsManager.js

@@ -0,0 +1,144 @@
+const { getProjectConfig, ensureProjectExists } = require('./projects');
+const {
+  fetchProjectComponentsMetadata,
+} = require('@hubspot/local-dev-lib/api/projects');
+const { i18n } = require('./lang');
+const { uiLink } = require('./ui');
+
+const i18nKey = 'commands.project.subcommands.logs';
+
+class ProjectLogsManager {
+  reset() {
+    Object.keys(this).forEach(key => {
+      if (Object.hasOwn(this, key)) {
+        this[key] = undefined;
+      }
+    });
+  }
+
+  async init(accountId) {
+    const { projectConfig } = await getProjectConfig();
+
+    if (!projectConfig || !projectConfig.name) {
+      throw new Error(i18n(`${i18nKey}.errors.noProjectConfig`));
+    }
+
+    const { name: projectName } = projectConfig;
+
+    this.projectName = projectName;
+    this.accountId = accountId;
+    this.functions = [];
+
+    const { project } = await ensureProjectExists(
+      this.accountId,
+      this.projectName,
+      {
+        allowCreate: false,
+      }
+    );
+
+    if (
+      !project ||
+      !project.deployedBuild ||
+      !project.deployedBuild.subbuildStatuses
+    ) {
+      throw new Error(i18n(`${i18nKey}.errors.failedToFetchProjectDetails`));
+    }
+
+    this.projectId = project.id;
+    await this.fetchFunctionDetails();
+  }
+
+  async fetchFunctionDetails() {
+    if (!this.projectId) {
+      throw new Error(i18n(`${i18nKey}.errors.noProjectConfig`));
+    }
+
+    const { topLevelComponentMetadata } = await fetchProjectComponentsMetadata(
+      this.accountId,
+      this.projectId
+    );
+
+    const apps = topLevelComponentMetadata.filter(componentMetadata => {
+      const { type } = componentMetadata;
+      return type && type.name === 'PRIVATE_APP';
+    });
+
+    if (!this.functions) {
+      this.functions = [];
+    }
+
+    apps.forEach(app => {
+      this.functions.push(
+        ...app.featureComponents.filter(
+          component => component.type.name === 'APP_FUNCTION'
+        )
+      );
+    });
+
+    if (this.functions.length === 0) {
+      throw new Error(
+        i18n(`${i18nKey}.errors.noFunctionsInProject`, {
+          link: uiLink(
+            i18n(`${i18nKey}.errors.noFunctionsLinkText`),
+            'https://developers.hubspot.com/docs/platform/serverless-functions'
+          ),
+        })
+      );
+    }
+  }
+
+  getFunctionNames() {
+    if (!this.functions) {
+      return [];
+    }
+    return this.functions.map(
+      serverlessFunction => serverlessFunction.componentName
+    );
+  }
+
+  setFunction(functionName) {
+    if (!this.functions) {
+      throw new Error(
+        i18n(`${i18nKey}.errors.noFunctionsInProject`, {
+          link: uiLink(
+            i18n(`${i18nKey}.errors.noFunctionsLinkText`),
+            'https://developers.hubspot.com/docs/platform/serverless-functions'
+          ),
+        }),
+        {
+          projectName: this.projectName,
+        }
+      );
+    }
+
+    this.selectedFunction = this.functions.find(
+      serverlessFunction => serverlessFunction.componentName === functionName
+    );
+
+    if (!this.selectedFunction) {
+      throw new Error(
+        i18n(`${i18nKey}.errors.noFunctionWithName`, { name: functionName })
+      );
+    }
+
+    this.functionName = functionName;
+
+    if (!this.selectedFunction.deployOutput) {
+      throw new Error(
+        i18n(`${i18nKey}.errors.functionNotDeployed`, { name: functionName })
+      );
+    }
+    this.appId = this.selectedFunction.deployOutput.appId;
+
+    if (this.selectedFunction.deployOutput.endpoint) {
+      this.endpointName = this.selectedFunction.deployOutput.endpoint.path;
+      this.method = this.selectedFunction.deployOutput.endpoint.method;
+      this.isPublicFunction = true;
+    } else {
+      this.isPublicFunction = false;
+    }
+  }
+}
+
+module.exports = new ProjectLogsManager();

package/lib/projects.js

@@ -287,10 +287,7 @@ const ensureProjectExists = async (
           );
           return { projectExists: true, project };
         } catch (err) {
-          return logApiErrorInstance(
-            err,
-            new ApiErrorContext({ accountId, projectName })
-          );
+          return logApiErrorInstance(err, new ApiErrorContext({ accountId }));
         }
       } else {
         if (!noLogs) {
@@ -312,7 +309,7 @@ const ensureProjectExists = async (
       logger.error(err.message);
       process.exit(EXIT_CODES.ERROR);
     }
-    logApiErrorInstance(err, new ApiErrorContext({ accountId, projectName }));
+    logApiErrorInstance(err, new ApiErrorContext({ accountId }));
     process.exit(EXIT_CODES.ERROR);
   }
 };
@@ -572,7 +569,7 @@ const handleProjectUpload = async (
           buildId
         );
       }
-      resolve(uploadResult);
+      resolve(uploadResult || {});
     })
   );
 

package/lib/projectsWatch.js

@@ -85,10 +85,7 @@ const debounceQueueBuild = (accountId, projectName, platformVersion) => {
         logger.log(i18n(`${i18nKey}.logs.watchCancelledFromUi`));
         process.exit(0);
       } else {
-        logApiErrorInstance(
-          err,
-          new ApiErrorContext({ accountId, projectName })
-        );
+        logApiErrorInstance(err, new ApiErrorContext({ accountId }));
       }
 
       return;
@@ -158,7 +155,7 @@ const createNewBuild = async (accountId, projectName, platformVersion) => {
     );
     return buildId;
   } catch (err) {
-    logApiErrorInstance(err, new ApiErrorContext({ accountId, projectName }));
+    logApiErrorInstance(err, new ApiErrorContext({ accountId }));
     if (
       isSpecifiedError(err, { subCategory: PROJECT_ERROR_TYPES.PROJECT_LOCKED })
     ) {

package/lib/prompts/__tests__/projectsLogsPrompt.test.js

@@ -0,0 +1,46 @@
+const { projectLogsPrompt } = require('../projectsLogsPrompt');
+
+jest.mock('../promptUtils');
+const { promptUser } = require('../promptUtils');
+const chalk = require('chalk');
+
+describe('prompts/projectsLogsPrompt', () => {
+  it('should return undefined functionName when functionChoices is nullable', async () => {
+    const actual = await projectLogsPrompt({ functionChoices: null });
+    expect(actual).toEqual({});
+    expect(promptUser).not.toHaveBeenCalled();
+  });
+
+  it('should return the functionName without prompting when there is only one functionChoice', async () => {
+    const functionChoice = 'this-is-the-only-function';
+    const { functionName } = await projectLogsPrompt({
+      functionChoices: [functionChoice],
+    });
+    expect(functionName).toEqual(functionChoice);
+    expect(promptUser).not.toHaveBeenCalled();
+  });
+
+  it('should prompt the user if there is more than one choice', async () => {
+    const functionChoices = ['choice 1', 'choice 2'];
+    const projectName = 'my cool project';
+    await projectLogsPrompt({
+      functionChoices,
+      projectName,
+    });
+
+    expect(promptUser).toHaveBeenCalledTimes(1);
+    expect(promptUser).toHaveBeenLastCalledWith(
+      expect.arrayContaining([
+        expect.objectContaining({
+          name: 'functionName',
+          type: 'list',
+          message: `[--function] Select function in ${chalk.bold(
+            projectName
+          )} project`,
+          when: expect.any(Function),
+          choices: functionChoices,
+        }),
+      ])
+    );
+  });
+});

package/lib/prompts/createProjectPrompt.js

@@ -4,6 +4,7 @@ const {
   getCwd,
   sanitizeFileName,
   isValidPath,
+  untildify,
 } = require('@hubspot/local-dev-lib/path');
 const { PROJECT_COMPONENT_TYPES } = require('../../lib/constants');
 const { promptUser } = require('./promptUtils');
@@ -100,6 +101,9 @@ const createProjectPrompt = async (
         }
         return true;
       },
+      filter: input => {
+        return untildify(input);
+      },
     },
     {
       name: 'template',

package/lib/prompts/projectDevTargetAccountPrompt.js

@@ -1,7 +1,7 @@
 const { promptUser } = require('./promptUtils');
 const { i18n } = require('../lang');
 const { uiAccountDescription, uiCommandReference } = require('../ui');
-const { isSandbox, isDeveloperTestAccount } = require('../accountTypes');
+const { isSandbox } = require('../accountTypes');
 const { getAccountId } = require('@hubspot/local-dev-lib/config');
 const { getSandboxUsageLimits } = require('@hubspot/local-dev-lib/sandboxes');
 const {
@@ -99,7 +99,6 @@ const selectDeveloperTestTargetAccountPrompt = async (
   defaultAccountConfig
 ) => {
   const defaultAccountId = getAccountId(defaultAccountConfig.name);
-  let choices = [];
   let devTestAccountsResponse = undefined;
   try {
     devTestAccountsResponse = await fetchDeveloperTestAccounts(
@@ -109,13 +108,6 @@ const selectDeveloperTestTargetAccountPrompt = async (
     logger.debug('Unable to fetch developer test account usage limits: ', err);
   }
 
-  const devTestAccounts = accounts
-    .reverse()
-    .filter(
-      config =>
-        isDeveloperTestAccount(config) &&
-        config.parentAccountId === defaultAccountId
-    );
   let disabledMessage = false;
   if (
     devTestAccountsResponse &&
@@ -128,27 +120,26 @@ const selectDeveloperTestTargetAccountPrompt = async (
     });
   }
 
-  let devTestAccountsNotInConfig = [];
+  const devTestAccounts = [];
   if (devTestAccountsResponse && devTestAccountsResponse.results) {
-    const inConfigIds = devTestAccounts.map(d => d.portalId);
+    const accountIds = accounts.map(account => account.portalId);
+
     devTestAccountsResponse.results.forEach(acct => {
-      if (inConfigIds.indexOf(acct.id) < 0) {
-        devTestAccountsNotInConfig.push({
-          name: getNonConfigDeveloperTestAccountName(acct),
-          value: {
-            targetAccountId: acct.id,
-            createdNestedAccount: false,
-            parentAccountId: defaultAccountId,
-            notInConfigAccount: acct,
-          },
-        });
-      }
+      const inConfig = accountIds.includes(acct.id);
+      devTestAccounts.push({
+        name: getNonConfigDeveloperTestAccountName(acct),
+        value: {
+          targetAccountId: acct.id,
+          createdNestedAccount: false,
+          parentAccountId: defaultAccountId,
+          notInConfigAccount: inConfig ? null : acct,
+        },
+      });
     });
   }
 
-  choices = [
-    ...devTestAccounts.map(mapNestedAccount),
-    ...devTestAccountsNotInConfig,
+  const choices = [
+    ...devTestAccounts,
     {
       name: i18n(`${i18nKey}.createNewDeveloperTestAccountOption`),
       value: {