@hubspot/cli 5.3.1 → 5.4.1-beta.0

package/commands/project/__tests__/logs.test.js

@@ -0,0 +1,305 @@
+jest.mock('../../../lib/commonOpts');
+jest.mock('../../../lib/usageTracking');
+jest.mock('../../../lib/validation');
+jest.mock('../../../lib/projectLogsManager');
+jest.mock('../../../lib/prompts/projectsLogsPrompt');
+jest.mock('@hubspot/local-dev-lib/logger');
+jest.mock('../../../lib/errorHandlers/apiErrors');
+jest.mock('../../../lib/ui/table');
+jest.mock('../../../lib/ui');
+jest.mock('../../../lib/errorHandlers/apiErrors');
+
+// Deps where we don't want mocks
+const libUi = jest.requireActual('../../../lib/ui');
+
+const { uiLine, uiLink, uiBetaTag } = require('../../../lib/ui');
+
+uiBetaTag.mockImplementation(libUi.uiBetaTag);
+
+const {
+  addUseEnvironmentOptions,
+  getAccountId,
+} = require('../../../lib/commonOpts');
+const ProjectLogsManager = require('../../../lib/projectLogsManager');
+const {
+  projectLogsPrompt,
+} = require('../../../lib/prompts/projectsLogsPrompt');
+const { getTableContents, getTableHeader } = require('../../../lib/ui/table');
+
+const { trackCommandUsage } = require('../../../lib/usageTracking');
+const { logApiErrorInstance } = require('../../../lib/errorHandlers/apiErrors');
+
+const {
+  handler,
+  describe: logsDescribe,
+  command,
+  builder,
+} = require('../logs');
+const { EXIT_CODES } = require('../../../lib/enums/exitCodes');
+
+describe('commands/project/logs', () => {
+  let processExitSpy;
+  beforeEach(() => {
+    processExitSpy = jest.spyOn(process, 'exit').mockImplementation(() => {});
+  });
+
+  describe('command', () => {
+    it('should have the proper command string', async () => {
+      expect(command).toEqual('logs');
+    });
+  });
+
+  describe('describe', () => {
+    it('should contain the beta tag', () => {
+      expect(logsDescribe).toContain('[BETA]');
+    });
+    it('should provide an accurate description of what the command is doing', () => {
+      expect(logsDescribe).toMatch(
+        /Get execution logs for a serverless function within a project/
+      );
+    });
+  });
+
+  describe('builder', () => {
+    let yargsMock = {};
+    beforeEach(() => {
+      yargsMock = {
+        options: jest.fn().mockImplementation(() => yargsMock),
+        conflicts: jest.fn().mockImplementation(() => yargsMock),
+        example: jest.fn().mockImplementation(() => yargsMock),
+      };
+    });
+
+    it('should add all of the options', () => {
+      builder(yargsMock);
+      expect(yargsMock.options).toHaveBeenCalledTimes(1);
+      expect(yargsMock.options).toHaveBeenCalledWith({
+        function: {
+          alias: 'function',
+          requiresArg: true,
+          describe: 'App function name',
+          type: 'string',
+        },
+        latest: {
+          alias: 'l',
+          type: 'boolean',
+          describe: 'Retrieve most recent log only',
+        },
+        compact: {
+          type: 'boolean',
+          describe: 'Output compact logs',
+        },
+        tail: {
+          alias: ['t', 'follow'],
+          describe: 'Tail logs',
+          type: 'boolean',
+        },
+        limit: {
+          type: 'number',
+          describe: 'Limit the number of logs to output',
+        },
+      });
+    });
+
+    it('should add the environment options', () => {
+      builder(yargsMock);
+      expect(addUseEnvironmentOptions).toHaveBeenCalledTimes(1);
+      expect(addUseEnvironmentOptions).toHaveBeenCalledWith(yargsMock);
+    });
+
+    it('should set tail and limit as conflicting arguments', () => {
+      builder(yargsMock);
+      expect(yargsMock.conflicts).toHaveBeenCalledTimes(1);
+      expect(yargsMock.conflicts).toHaveBeenCalledWith('tail', 'limit');
+    });
+
+    it('should set examples', () => {
+      builder(yargsMock);
+      expect(yargsMock.example).toHaveBeenCalledTimes(1);
+      expect(yargsMock.example).toHaveBeenCalledWith([
+        [
+          '$0 project logs',
+          'Open the project logs prompt to get logs for a serverless function',
+        ],
+        [
+          '$0 project logs --function=my-function',
+          'Get logs for function named "my-function" within the app named "app" within the project named "my-project"',
+        ],
+      ]);
+    });
+  });
+
+  describe('handler', () => {
+    const accountId = 12345678;
+
+    beforeEach(() => {
+      getAccountId.mockReturnValue(accountId);
+      projectLogsPrompt.mockResolvedValue({ functionName: 'foo' });
+    });
+
+    it('should get the account id', async () => {
+      const options = {
+        foo: 'bar',
+      };
+      await handler(options);
+      expect(getAccountId).toHaveBeenCalledTimes(1);
+      expect(getAccountId).toHaveBeenCalledWith(options);
+    });
+
+    it('should track the command usage', async () => {
+      const options = {
+        foo: 'bar',
+      };
+      await handler(options);
+      expect(trackCommandUsage).toHaveBeenCalledTimes(1);
+      expect(trackCommandUsage).toHaveBeenCalledWith(
+        'project-logs',
+        null,
+        accountId
+      );
+    });
+
+    it('should initialize the ProjectLogsManager', async () => {
+      const options = {
+        foo: 'bar',
+      };
+      await handler(options);
+      expect(ProjectLogsManager.init).toHaveBeenCalledTimes(1);
+      expect(ProjectLogsManager.init).toHaveBeenCalledWith(accountId);
+    });
+
+    it('should prompt the user for input', async () => {
+      const functionNames = ['function1', 'function2'];
+      ProjectLogsManager.getFunctionNames.mockReturnValue(functionNames);
+      const options = {
+        foo: 'bar',
+      };
+      await handler(options);
+      expect(projectLogsPrompt).toHaveBeenCalledTimes(1);
+      expect(projectLogsPrompt).toHaveBeenCalledWith({
+        functionChoices: functionNames,
+        promptOptions: options,
+      });
+    });
+
+    it('should set the function', async () => {
+      const selectedFunction = 'function1';
+      ProjectLogsManager.getFunctionNames.mockReturnValue([
+        selectedFunction,
+        'function2',
+      ]);
+      projectLogsPrompt.mockReturnValue({
+        functionName: selectedFunction,
+      });
+
+      await handler({});
+      expect(ProjectLogsManager.setFunction).toHaveBeenCalledTimes(1);
+      expect(ProjectLogsManager.setFunction).toHaveBeenCalledWith(
+        selectedFunction
+      );
+    });
+
+    it('should log public functions correctly', async () => {
+      const functionNames = ['function1', 'function2'];
+      const selectedFunction = 'function1';
+      ProjectLogsManager.getFunctionNames.mockReturnValue(functionNames);
+      projectLogsPrompt.mockReturnValue({
+        functionName: selectedFunction,
+      });
+
+      const tableHeaders = ['Header 1', 'Header 2'];
+      getTableHeader.mockReturnValue(tableHeaders);
+
+      ProjectLogsManager.isPublicFunction = true;
+      ProjectLogsManager.accountId = accountId;
+      ProjectLogsManager.functionName = selectedFunction;
+      ProjectLogsManager.endpointName = 'my-endpoint';
+      ProjectLogsManager.appId = 123456;
+
+      await handler({});
+      expect(getTableHeader).toHaveBeenCalledTimes(1);
+      expect(getTableHeader).toHaveBeenCalledWith([
+        'Account',
+        'Function',
+        'Endpoint',
+      ]);
+
+      expect(getTableContents).toHaveBeenCalledTimes(1);
+      expect(getTableContents).toHaveBeenCalledWith(
+        [
+          tableHeaders,
+          [
+            ProjectLogsManager.accountId,
+            ProjectLogsManager.functionName,
+            ProjectLogsManager.endpointName,
+          ],
+        ],
+        { border: { bodyLeft: '  ' } }
+      );
+      expect(uiLink).toHaveBeenCalledTimes(1);
+      expect(uiLink).toHaveBeenCalledWith(
+        'View function logs in HubSpot',
+        `https://app.hubspot.com/private-apps/${accountId}/${ProjectLogsManager.appId}/logs/serverlessGatewayExecution?path=${ProjectLogsManager.endpointName}`
+      );
+      expect(uiLine).toHaveBeenCalledTimes(1);
+    });
+
+    it('should log private functions correctly', async () => {
+      const functionNames = ['function1', 'function2'];
+      const selectedFunction = 'function1';
+
+      ProjectLogsManager.getFunctionNames.mockReturnValue(functionNames);
+      projectLogsPrompt.mockReturnValue({
+        functionName: selectedFunction,
+      });
+
+      const tableHeaders = ['Header 1', 'Header 2'];
+      getTableHeader.mockReturnValue(tableHeaders);
+
+      ProjectLogsManager.isPublicFunction = false;
+      ProjectLogsManager.accountId = accountId;
+      ProjectLogsManager.functionName = selectedFunction;
+      ProjectLogsManager.appId = 456789;
+
+      await handler({});
+      expect(getTableHeader).toHaveBeenCalledTimes(1);
+      expect(getTableHeader).toHaveBeenCalledWith(['Account', 'Function']);
+
+      expect(getTableContents).toHaveBeenCalledTimes(1);
+      expect(getTableContents).toHaveBeenCalledWith(
+        [
+          tableHeaders,
+          [ProjectLogsManager.accountId, ProjectLogsManager.functionName],
+        ],
+        { border: { bodyLeft: '  ' } }
+      );
+
+      expect(uiLink).toHaveBeenCalledWith(
+        'View function logs in HubSpot',
+        `https://app.hubspot.com/private-apps/${accountId}/${ProjectLogsManager.appId}/logs/crm?serverlessFunction=${selectedFunction}`
+      );
+
+      expect(uiLine).toHaveBeenCalledTimes(1);
+    });
+
+    it('should handle errors correctly', async () => {
+      const error = new Error('Something went wrong');
+      ProjectLogsManager.init.mockImplementation(() => {
+        throw error;
+      });
+
+      ProjectLogsManager.projectName = 'Super cool project';
+
+      await handler({});
+
+      expect(logApiErrorInstance).toHaveBeenCalledTimes(1);
+      expect(logApiErrorInstance).toHaveBeenCalledWith(error, {
+        accountId: accountId,
+        projectName: ProjectLogsManager.projectName,
+      });
+
+      expect(processExitSpy).toHaveBeenCalledTimes(1);
+      expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+    });
+  });
+});

package/commands/project/add.js

@@ -6,7 +6,10 @@ const { fetchReleaseData } = require('@hubspot/local-dev-lib/github');
 const { trackCommandUsage } = require('../../lib/usageTracking');
 const { i18n } = require('../../lib/lang');
 const { projectAddPrompt } = require('../../lib/prompts/projectAddPrompt');
-const { createProjectComponent } = require('../../lib/projects');
+const {
+  createProjectComponent,
+  getProjectComponentsByVersion,
+} = require('../../lib/projects');
 const { loadAndValidateOptions } = require('../../lib/validation');
 const { uiBetaTag } = require('../../lib/ui');
 const {
@@ -21,34 +24,37 @@ exports.describe = uiBetaTag(i18n(`${i18nKey}.describe`), false);
 exports.handler = async options => {
   await loadAndValidateOptions(options);
 
-  const accountId = getAccountId(options);
-
   logger.log('');
   logger.log(i18n(`${i18nKey}.creatingComponent.message`));
   logger.log('');
 
+  const accountId = getAccountId(options);
+
   const releaseData = await fetchReleaseData(
     HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH
   );
   const projectComponentsVersion = releaseData.tag_name;
 
-  const { type, name } = await projectAddPrompt(
-    projectComponentsVersion,
-    options
+  const components = await getProjectComponentsByVersion(
+    projectComponentsVersion
   );
 
+  let { component, name } = await projectAddPrompt(components, options);
+
+  name = name || options.name;
+
+  if (!component) {
+    component = components.find(t => t.path === options.type);
+  }
+
   trackCommandUsage('project-add', null, accountId);
 
   try {
-    await createProjectComponent(
-      options.type || type,
-      options.name || name,
-      projectComponentsVersion
-    );
+    await createProjectComponent(component, name, projectComponentsVersion);
     logger.log('');
     logger.log(
       i18n(`${i18nKey}.success.message`, {
-        componentName: options.name || name,
+        componentName: name,
       })
     );
   } catch (error) {
@@ -69,6 +75,12 @@ exports.builder = yargs => {
   });
 
   yargs.example([['$0 project add', i18n(`${i18nKey}.examples.default`)]]);
+  yargs.example([
+    [
+      '$0 project add --name="my-component" --type="components/example-app"',
+      i18n(`${i18nKey}.examples.withFlags`),
+    ],
+  ]);
 
   return yargs;
 };

package/commands/project/cloneApp.js

@@ -38,13 +38,10 @@ const {
   checkCloneStatus,
   downloadClonedProject,
 } = require('@hubspot/local-dev-lib/api/projects');
-const { getCwd } = require('@hubspot/local-dev-lib/path');
+const { getCwd, sanitizeFileName } = require('@hubspot/local-dev-lib/path');
 const { logger } = require('@hubspot/local-dev-lib/logger');
 const { getAccountConfig } = require('@hubspot/local-dev-lib/config');
 const { extractZipArchive } = require('@hubspot/local-dev-lib/archive');
-const {
-  fetchPublicAppMetadata,
-} = require('@hubspot/local-dev-lib/api/appsDev');
 
 const i18nKey = 'commands.project.subcommands.cloneApp';
 
@@ -76,8 +73,6 @@ exports.handler = async options => {
   let appId;
   let name;
   let location;
-  let preventProjectMigrations;
-  let listingInfo;
   try {
     appId = options.appId;
     if (!appId) {
@@ -89,11 +84,6 @@ exports.handler = async options => {
       });
       appId = appIdResponse.appId;
     }
-    const selectedApp = await fetchPublicAppMetadata(appId, accountId);
-    // preventProjectMigrations returns true if we have not added app to allowlist config.
-    // listingInfo will only exist for marketplace apps
-    preventProjectMigrations = selectedApp.preventProjectMigrations;
-    listingInfo = selectedApp.listingInfo;
 
     const projectResponse = await createProjectPrompt('', options, true);
     name = projectResponse.name;
@@ -119,10 +109,15 @@ exports.handler = async options => {
 
       // Extract zipped app files and place them in correct directory
       const zippedApp = await downloadClonedProject(accountId, exportId);
-      await extractZipArchive(zippedApp, name, absoluteDestPath, {
-        includesRootDir: true,
-        hideLogs: true,
-      });
+      await extractZipArchive(
+        zippedApp,
+        sanitizeFileName(name),
+        absoluteDestPath,
+        {
+          includesRootDir: true,
+          hideLogs: true,
+        }
+      );
 
       // Create hsproject.json file
       const configPath = path.join(baseDestPath, PROJECT_CONFIG_FILE);
@@ -133,15 +128,12 @@ exports.handler = async options => {
       };
       const success = writeProjectConfig(configPath, configContent);
 
-      const isListed = Boolean(listingInfo);
       trackCommandMetadataUsage(
         'clone-app',
         {
-          projectName: name,
-          appId,
-          status,
-          preventProjectMigrations,
-          isListed,
+          type: name,
+          assetType: appId,
+          successful: success,
         },
         accountId
       );

package/commands/project/deploy.js

@@ -170,7 +170,10 @@ exports.handler = async options => {
     } else if (e.response && e.response.status === 400) {
       logger.error(e.message);
     } else {
-      logApiErrorInstance(e, new ApiErrorContext({ accountId, projectName }));
+      logApiErrorInstance(
+        e,
+        new ApiErrorContext({ accountId, request: 'project deploy' })
+      );
     }
     return process.exit(EXIT_CODES.ERROR);
   }

package/commands/project/dev.js

@@ -46,12 +46,12 @@ const {
   confirmDefaultAccountIsTarget,
   suggestRecommendedNestedAccount,
   checkIfAppDeveloperAccount,
-  checkIfDeveloperTestAccount,
   createSandboxForLocalDev,
   createDeveloperTestAccountForLocalDev,
   createNewProjectForLocalDev,
   createInitialBuildForNewProject,
   useExistingDevTestAccount,
+  validateAccountOption,
 } = require('../../lib/localDev');
 
 const i18nKey = 'commands.project.subcommands.dev';
@@ -86,11 +86,20 @@ exports.handler = async options => {
   validateProjectConfig(projectConfig, projectDir);
 
   const components = await findProjectComponents(projectDir);
-  const componentTypes = getProjectComponentTypes(components);
+  const runnableComponents = components.filter(component => component.runnable);
+  const componentTypes = getProjectComponentTypes(runnableComponents);
   const hasPrivateApps = !!componentTypes[COMPONENT_TYPES.privateApp];
   const hasPublicApps = !!componentTypes[COMPONENT_TYPES.publicApp];
 
-  if (hasPrivateApps && hasPublicApps) {
+  if (runnableComponents.length === 0) {
+    logger.error(
+      i18n(`${i18nKey}.errors.noRunnableComponents`, {
+        projectDir,
+        command: uiCommandReference('hs project add'),
+      })
+    );
+    process.exit(EXIT_CODES.SUCCESS);
+  } else if (hasPrivateApps && hasPublicApps) {
     logger.error(i18n(`${i18nKey}.errors.invalidProjectComponents`));
     process.exit(EXIT_CODES.SUCCESS);
   }
@@ -106,14 +115,13 @@ exports.handler = async options => {
   // The account that we are locally testing against
   let targetTestingAccountId = options.account ? accountId : null;
 
-  if (options.account && hasPublicApps) {
-    checkIfDeveloperTestAccount(accountConfig);
-    targetProjectAccountId = accountConfig.parentAccountId;
-    targetTestingAccountId = accountId;
-  }
+  if (options.account) {
+    validateAccountOption(accountConfig, hasPublicApps);
 
-  let createNewSandbox = false;
-  let createNewDeveloperTestAccount = false;
+    if (hasPublicApps) {
+      targetProjectAccountId = accountConfig.parentAccountId;
+    }
+  }
 
   // The user is targeting an account type that we recommend developing on
   if (!targetProjectAccountId && defaultAccountIsRecommendedType) {
@@ -143,6 +151,9 @@ exports.handler = async options => {
     checkIfAppDeveloperAccount(accountConfig);
   }
 
+  let createNewSandbox = false;
+  let createNewDeveloperTestAccount = false;
+
   if (!targetProjectAccountId) {
     const {
       targetAccountId,
@@ -222,7 +233,7 @@ exports.handler = async options => {
   }
 
   const LocalDev = new LocalDevManager({
-    components,
+    runnableComponents,
     debug: options.debug,
     deployedBuild,
     isGithubLinked,

package/commands/project/download.js

@@ -6,7 +6,7 @@ const {
   addUseEnvironmentOptions,
 } = require('../../lib/commonOpts');
 const { trackCommandUsage } = require('../../lib/usageTracking');
-const { getCwd } = require('@hubspot/local-dev-lib/path');
+const { getCwd, sanitizeFileName } = require('@hubspot/local-dev-lib/path');
 const {
   logApiErrorInstance,
   ApiErrorContext,
@@ -95,7 +95,7 @@ exports.handler = async options => {
 
     await extractZipArchive(
       zippedProject,
-      projectName,
+      sanitizeFileName(projectName),
       path.resolve(absoluteDestPath),
       { includesRootDir: false }
     );
@@ -108,7 +108,10 @@ exports.handler = async options => {
     );
     process.exit(EXIT_CODES.SUCCESS);
   } catch (e) {
-    logApiErrorInstance(e, new ApiErrorContext({ accountId, projectName }));
+    logApiErrorInstance(
+      e,
+      new ApiErrorContext({ accountId, request: 'project download' })
+    );
     process.exit(EXIT_CODES.ERROR);
   }
 };

package/commands/project/installDeps.js

@@ -0,0 +1,78 @@
+const {
+  installPackages,
+  getProjectPackageJsonLocations,
+} = require('../../lib/dependencyManagement');
+const { logger } = require('@hubspot/local-dev-lib/logger');
+const { EXIT_CODES } = require('../../lib/enums/exitCodes');
+const { getProjectConfig } = require('../../lib/projects');
+const { promptUser } = require('../../lib/prompts/promptUtils');
+const path = require('path');
+const { i18n } = require('../../lib/lang');
+const { trackCommandUsage } = require('../../lib/usageTracking');
+const { getAccountId } = require('../../lib/commonOpts');
+
+const i18nKey = `commands.project.subcommands.installDeps`;
+
+exports.command = 'install-deps [packages..]';
+// Intentionally making this null to hide command
+exports.describe = null;
+// exports.describe = uiBetaTag(i18n(`${i18nKey}.help.describe`), false);
+
+exports.handler = async ({ packages }) => {
+  try {
+    const accountId = getAccountId();
+    trackCommandUsage('project-install-deps', null, accountId);
+
+    const projectConfig = await getProjectConfig();
+    if (!projectConfig || !projectConfig.projectDir) {
+      logger.error(i18n(`${i18nKey}.noProjectConfig`));
+      return process.exit(EXIT_CODES.ERROR);
+    }
+
+    const { projectDir } = projectConfig;
+
+    let installLocations = await getProjectPackageJsonLocations();
+    if (packages) {
+      const { selectedInstallLocations } = await promptUser([
+        {
+          name: 'selectedInstallLocations',
+          type: 'checkbox',
+          when: () => packages && packages.length > 0,
+          message: i18n(`${i18nKey}.installLocationPrompt`),
+          choices: installLocations.map(dir => ({
+            name: path.relative(projectDir, dir),
+            value: dir,
+          })),
+          validate: choices => {
+            if (choices === undefined || choices.length === 0) {
+              return i18n(`${i18nKey}.installLocationPromptRequired`);
+            }
+            return true;
+          },
+        },
+      ]);
+      if (selectedInstallLocations) {
+        installLocations = selectedInstallLocations;
+      }
+    }
+
+    await installPackages({
+      packages,
+      installLocations,
+    });
+  } catch (e) {
+    logger.debug(e);
+    logger.error(e.message);
+    return process.exit(EXIT_CODES.ERROR);
+  }
+};
+
+exports.builder = yargs => {
+  yargs.example([
+    ['$0 project install-deps', i18n(`${i18nKey}.help.installAppDepsExample`)],
+    [
+      '$0 project install-deps dependency1 dependency2',
+      i18n(`${i18nKey}.help.addDepToSubComponentExample`),
+    ],
+  ]);
+};