@hubspot/cli 5.3.1 → 5.4.1-beta.0

package/lib/__tests__/projectLogsManager.test.js

@@ -0,0 +1,210 @@
+jest.mock('../projects');
+jest.mock('@hubspot/local-dev-lib/api/projects');
+
+const ProjectLogsManager = require('../projectLogsManager');
+const { getProjectConfig, ensureProjectExists } = require('../projects');
+const {
+  fetchProjectComponentsMetadata,
+} = require('@hubspot/local-dev-lib/api/projects');
+
+describe('cli/lib/projectLogsManager', () => {
+  const accountId = 12345678;
+  const appId = 999999;
+  const projectName = 'super cool test project';
+  const projectConfig = { projectConfig: { name: projectName } };
+  const projectId = 987654321;
+  const projectDetails = {
+    project: {
+      id: projectId,
+      deployedBuild: {
+        subbuildStatuses: {},
+      },
+    },
+  };
+
+  const function1 = {
+    componentName: 'function1',
+    type: {
+      name: 'APP_FUNCTION',
+    },
+    deployOutput: {
+      appId,
+    },
+  };
+  const functions = [
+    function1,
+    {
+      componentName: 'function2',
+      type: {
+        name: 'APP_FUNCTION',
+      },
+      deployOutput: {
+        appId,
+      },
+    },
+  ];
+
+  beforeEach(() => {
+    ProjectLogsManager.reset();
+
+    getProjectConfig.mockResolvedValue(projectConfig);
+    ensureProjectExists.mockResolvedValue(projectDetails);
+    fetchProjectComponentsMetadata.mockResolvedValue({
+      topLevelComponentMetadata: [
+        {
+          type: {
+            name: 'PRIVATE_APP',
+          },
+          deployOutput: {
+            appId,
+          },
+          featureComponents: [
+            ...functions,
+            {
+              type: {
+                name: 'NOT_AN_APP_FUNCTION',
+              },
+            },
+          ],
+        },
+      ],
+    });
+  });
+
+  describe('init', () => {
+    it('should load the project config', async () => {
+      await ProjectLogsManager.init(accountId);
+      expect(getProjectConfig).toHaveBeenCalledTimes(1);
+    });
+
+    it('should throw an error if there is a problem with the config', async () => {
+      getProjectConfig.mockResolvedValue({});
+      await expect(async () =>
+        ProjectLogsManager.init(accountId)
+      ).rejects.toThrow(
+        'No project detected. Run this command again from a project directory.'
+      );
+      expect(getProjectConfig).toHaveBeenCalledTimes(1);
+    });
+
+    it('should ensure the project exists', async () => {
+      await ProjectLogsManager.init(accountId);
+      expect(ensureProjectExists).toHaveBeenCalledTimes(1);
+      expect(ensureProjectExists).toHaveBeenCalledWith(accountId, projectName, {
+        allowCreate: false,
+      });
+    });
+
+    it('should throw an error if there is data missing from the project details', async () => {
+      ensureProjectExists.mockResolvedValue({});
+      await expect(async () =>
+        ProjectLogsManager.init(accountId)
+      ).rejects.toThrow(/There was an error fetching project details/);
+    });
+
+    it('should set all of the expected fields correctly', async () => {
+      await ProjectLogsManager.init(accountId);
+      expect(ProjectLogsManager.projectId).toEqual(projectId);
+      expect(ProjectLogsManager.projectName).toEqual(projectName);
+      expect(ProjectLogsManager.accountId).toEqual(accountId);
+      expect(ProjectLogsManager.functions).toEqual(functions);
+    });
+  });
+
+  describe('fetchFunctionDetails', () => {
+    it('should throw an error if the projectId is null when the method is called', async () => {
+      await expect(async () =>
+        ProjectLogsManager.fetchFunctionDetails()
+      ).rejects.toThrow(
+        'No project detected. Run this command again from a project directory.'
+      );
+    });
+
+    it('should fetch the component metadata', async () => {
+      ProjectLogsManager.projectId = projectId;
+      ProjectLogsManager.accountId = accountId;
+      await ProjectLogsManager.fetchFunctionDetails();
+      expect(fetchProjectComponentsMetadata).toHaveBeenCalledTimes(1);
+      expect(fetchProjectComponentsMetadata).toHaveBeenCalledWith(
+        accountId,
+        projectId
+      );
+    });
+
+    it('should set the functions correctly', async () => {
+      ProjectLogsManager.projectId = projectId;
+      ProjectLogsManager.accountId = accountId;
+      await ProjectLogsManager.fetchFunctionDetails();
+      expect(ProjectLogsManager.functions).toEqual(functions);
+    });
+  });
+
+  describe('getFunctionNames', () => {
+    it('should return an empty array if functions is nullable', async () => {
+      ProjectLogsManager.functions = undefined;
+      expect(ProjectLogsManager.getFunctionNames()).toEqual([]);
+    });
+
+    it('should return an array of the componentNames', async () => {
+      ProjectLogsManager.functions = functions;
+      expect(ProjectLogsManager.getFunctionNames()).toEqual([
+        'function1',
+        'function2',
+      ]);
+    });
+  });
+
+  describe('setFunction', () => {
+    it('should throw an error when functions is nullable', async () => {
+      ProjectLogsManager.functions = undefined;
+      expect(() => ProjectLogsManager.setFunction('foo')).toThrow(
+        `There aren't any functions in this project`
+      );
+    });
+
+    it('should throw an error when the provided function is invalid', async () => {
+      ProjectLogsManager.functions = functions;
+      const badName = 'foo';
+      expect(() => ProjectLogsManager.setFunction(badName)).toThrow(
+        `No function with name "${badName}"`
+      );
+    });
+
+    it('should set the data correctly for public functions', async () => {
+      const functionToChoose = {
+        componentName: 'function1',
+        type: {
+          name: 'APP_FUNCTION',
+        },
+        deployOutput: {
+          endpoint: { path: 'yooooooo', method: ['GET'] },
+        },
+      };
+      ProjectLogsManager.functions = [functionToChoose];
+      ProjectLogsManager.setFunction('function1');
+      expect(ProjectLogsManager.functionName).toEqual('function1');
+      expect(ProjectLogsManager.endpointName).toEqual('yooooooo');
+      expect(ProjectLogsManager.selectedFunction).toEqual(functionToChoose);
+      expect(ProjectLogsManager.method).toEqual(['GET']);
+      expect(ProjectLogsManager.isPublicFunction).toEqual(true);
+    });
+
+    it('should set the data correctly for public functions', async () => {
+      ProjectLogsManager.functions = functions;
+      ProjectLogsManager.setFunction('function1');
+      expect(ProjectLogsManager.selectedFunction).toEqual(function1);
+      expect(ProjectLogsManager.functionName).toEqual('function1');
+      expect(ProjectLogsManager.isPublicFunction).toEqual(false);
+    });
+  });
+
+  describe('reset', () => {
+    it('should reset all the values', async () => {
+      ProjectLogsManager.someRandomField = 'value';
+      expect(ProjectLogsManager.someRandomField).toBeDefined();
+
+      ProjectLogsManager.reset();
+      expect(ProjectLogsManager.isPublicFunction).toBeUndefined();
+    });
+  });
+});

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

@@ -85,15 +85,32 @@ const confirmDefaultAccountIsTarget = async accountConfig => {
 // Confirm the default account is a developer account if developing public apps
 const checkIfAppDeveloperAccount = accountConfig => {
   if (!isAppDeveloperAccount(accountConfig)) {
-    logger.error(i18n(`${i18nKey}.checkIfAppDevloperAccount`));
+    logger.error(
+      i18n(`${i18nKey}.checkIfAppDevloperAccount`, {
+        useCommand: uiCommandReference('hs accounts use'),
+        authCommand: uiCommandReference('hs auth'),
+      })
+    );
     process.exit(EXIT_CODES.SUCCESS);
   }
 };
 
 // Confirm the default account is a developer account if developing public apps
-const checkIfDeveloperTestAccount = accountConfig => {
-  if (!isDeveloperTestAccount(accountConfig)) {
-    logger.error(i18n(`${i18nKey}.checkIfDeveloperTestAccount`));
+const validateAccountOption = (accountConfig, hasPublicApps) => {
+  if (hasPublicApps && !isDeveloperTestAccount(accountConfig)) {
+    logger.error(
+      i18n(`${i18nKey}.validateAccountOption.invalidPublicAppAccount`, {
+        useCommand: uiCommandReference('hs accounts use'),
+        devCommand: uiCommandReference('hs project dev'),
+      })
+    );
+    process.exit(EXIT_CODES.SUCCESS);
+  } else if (isAppDeveloperAccount(accountConfig)) {
+    logger.error(
+      i18n(`${i18nKey}.validateAccountOption.invalidPrivateAppAccount`, {
+        useCommand: uiCommandReference('hs accounts use'),
+      })
+    );
     process.exit(EXIT_CODES.SUCCESS);
   }
 };
@@ -109,20 +126,11 @@ const suggestRecommendedNestedAccount = async (
   if (hasPublicApps) {
     logger.log(
       i18n(
-        `${i18nKey}.suggestRecommendedNestedAccount.publicAppNonDeveloperTestAccountWarning`
+        `${i18nKey}.validateAccountOption.publicAppNonDeveloperTestAccountWarning`
       )
     );
-  } else if (isAppDeveloperAccount(accountConfig)) {
-    logger.error(
-      i18n(
-        `${i18nKey}.suggestRecommendedNestedAccount.privateAppInAppDeveloperAccountError`
-      )
-    );
-    process.exit(EXIT_CODES.ERROR);
   } else {
-    logger.log(
-      i18n(`${i18nKey}.suggestRecommendedNestedAccount.nonSandboxWarning`)
-    );
+    logger.log(i18n(`${i18nKey}.validateAccountOption.nonSandboxWarning`));
   }
   uiLine();
   logger.log();
@@ -187,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,
@@ -439,7 +448,7 @@ const getAccountHomeUrl = accountId => {
 module.exports = {
   confirmDefaultAccountIsTarget,
   checkIfAppDeveloperAccount,
-  checkIfDeveloperTestAccount,
+  validateAccountOption,
   suggestRecommendedNestedAccount,
   createSandboxForLocalDev,
   createDeveloperTestAccountForLocalDev,