@hubspot/cli 5.4.0 → 6.0.0

package/commands/__tests__/projects.test.js

@@ -0,0 +1,105 @@
+const { command, describe: projectDescribe, builder } = require('../project');
+
+jest.mock('../project/deploy');
+jest.mock('../project/create');
+jest.mock('../project/upload');
+jest.mock('../project/listBuilds');
+jest.mock('../project/logs');
+jest.mock('../project/watch');
+jest.mock('../project/download');
+jest.mock('../project/open');
+jest.mock('../project/dev');
+jest.mock('../project/add');
+jest.mock('../project/migrateApp');
+jest.mock('../project/cloneApp');
+jest.mock('../project/installDeps');
+jest.mock('../../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');
+const download = require('../project/download');
+const open = require('../project/open');
+const dev = require('../project/dev');
+const add = require('../project/add');
+const migrateApp = require('../project/migrateApp');
+const cloneApp = require('../project/cloneApp');
+const installDeps = require('../project/installDeps');
+const { addConfigOptions, addAccountOptions } = require('../../lib/commonOpts');
+
+describe('commands/projects', () => {
+  describe('command', () => {
+    it('should have the correct command structure', () => {
+      expect(command).toEqual('project');
+    });
+  });
+
+  describe('describe', () => {
+    it('should contain the beta tag', () => {
+      expect(projectDescribe).toContain('[BETA]');
+    });
+    it('should provide an accurate description of what the command is doing', () => {
+      expect(projectDescribe).toContain(
+        'Commands for working with projects. For more information, visit our documentation: https://developers.hubspot.com/docs/platform/build-and-deploy-using-hubspot-projects'
+      );
+    });
+  });
+
+  describe('builder', () => {
+    let yargs;
+
+    const subcommands = [
+      ['create', create],
+      ['add', add],
+      ['watch', watch],
+      ['dev', dev],
+      ['upload', upload],
+      ['deploy', deploy],
+      ['logs', logs],
+      ['listBuilds', listBuilds],
+      ['download', download],
+      ['open', open],
+      ['migrateApp', migrateApp],
+      ['cloneApp', cloneApp],
+      ['installDeps', installDeps],
+    ];
+
+    beforeEach(() => {
+      yargs = {
+        command: jest.fn().mockImplementation(() => yargs),
+        demandCommand: jest.fn().mockImplementation(() => yargs),
+      };
+    });
+
+    it('should add the config options', () => {
+      builder(yargs);
+      expect(addConfigOptions).toHaveBeenCalledTimes(1);
+      expect(addConfigOptions).toHaveBeenCalledWith(yargs);
+    });
+
+    it('should add the account options', () => {
+      builder(yargs);
+      expect(addAccountOptions).toHaveBeenCalledTimes(1);
+      expect(addAccountOptions).toHaveBeenCalledWith(yargs);
+    });
+
+    it('should add the correct number of sub commands', () => {
+      builder(yargs);
+      expect(yargs.command).toHaveBeenCalledTimes(subcommands.length);
+    });
+
+    it.each(subcommands)('should attach the %s subcommand', (name, module) => {
+      builder(yargs);
+      expect(yargs.command).toHaveBeenCalledWith(module);
+    });
+
+    it('should demand the command takes one positional argument', () => {
+      builder(yargs);
+      expect(yargs.demandCommand).toHaveBeenCalledTimes(1);
+      expect(yargs.demandCommand).toHaveBeenCalledWith(1, '');
+    });
+  });
+});

package/commands/accounts/clean.js

@@ -54,7 +54,7 @@ exports.handler = async options => {
 
   for (const account of filteredTestAccounts) {
     try {
-      await accessTokenForPersonalAccessKey(account.portalId);
+      await accessTokenForPersonalAccessKey(account.portalId, true);
     } catch (error) {
       if (
         isSpecifiedHubSpotAuthError(error, {

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

@@ -423,7 +423,7 @@ describe('commands/project/deploy', () => {
 
       expect(logger.error).toHaveBeenCalledTimes(1);
       expect(logger.error).toHaveBeenCalledWith(
-        `The request in account ${accountId} failed due to a client error.`
+        `The request for 'project deploy' in account ${accountId} failed due to a client error.`
       );
       expect(processExitSpy).toHaveBeenCalledTimes(1);
       expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);

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

@@ -0,0 +1,168 @@
+jest.mock('../../../lib/projects');
+jest.mock('@hubspot/local-dev-lib/logger');
+jest.mock('../../../lib/dependencyManagement');
+jest.mock('../../../lib/prompts/promptUtils');
+jest.mock('../../../lib/usageTracking');
+jest.mock('../../../lib/commonOpts');
+
+const { getProjectConfig } = require('../../../lib/projects');
+const { EXIT_CODES } = require('../../../lib/enums/exitCodes');
+const { logger } = require('@hubspot/local-dev-lib/logger');
+const { trackCommandUsage } = require('../../../lib/usageTracking');
+const { getAccountId } = require('../../../lib/commonOpts');
+const {
+  installPackages,
+  getProjectPackageJsonLocations,
+} = require('../../../lib/dependencyManagement');
+const { promptUser } = require('../../../lib/prompts/promptUtils');
+const {
+  command,
+  describe: installDepsDescribe,
+  builder,
+  handler,
+} = require('../installDeps');
+const path = require('path');
+
+describe('commands/project/installDeps', () => {
+  describe('command', () => {
+    it('should have the correct command string', () => {
+      expect(command).toEqual('install-deps [packages..]');
+    });
+  });
+
+  describe('describe', () => {
+    it('should have the correct description', () => {
+      expect(installDepsDescribe).toEqual(null);
+    });
+  });
+
+  describe('builder', () => {
+    let yargs;
+    beforeEach(() => {
+      yargs = {
+        example: jest.fn().mockImplementation(() => yargs),
+      };
+    });
+
+    it('should add correct examples', () => {
+      builder(yargs);
+      expect(yargs.example).toHaveBeenCalledTimes(1);
+      expect(yargs.example).toHaveBeenCalledWith([
+        ['$0 project install-deps', 'Install the dependencies for the project'],
+        [
+          '$0 project install-deps dependency1 dependency2',
+          'Install the dependencies to one or more project subcomponents',
+        ],
+      ]);
+    });
+  });
+
+  describe('handler', () => {
+    let processExitSpy;
+
+    beforeEach(() => {
+      processExitSpy = jest.spyOn(process, 'exit').mockImplementation(() => {});
+    });
+
+    it('should track the command usage', async () => {
+      const accountId = 999999;
+      getAccountId.mockReturnValue(accountId);
+      await handler({});
+
+      expect(getAccountId).toHaveBeenCalledTimes(1);
+      expect(trackCommandUsage).toHaveBeenCalledTimes(1);
+      expect(trackCommandUsage).toHaveBeenCalledWith(
+        'project-install-deps',
+        null,
+        accountId
+      );
+    });
+
+    it('should handle exceptions', async () => {
+      const error = new Error('Something went super wrong');
+
+      getProjectConfig.mockImplementationOnce(() => {
+        throw error;
+      });
+
+      await handler({});
+
+      expect(logger.debug).toHaveBeenCalledTimes(1);
+      expect(logger.debug).toHaveBeenCalledWith(error);
+
+      expect(logger.error).toHaveBeenCalledTimes(1);
+      expect(logger.error).toHaveBeenCalledWith(error.message);
+
+      expect(processExitSpy).toHaveBeenCalledTimes(1);
+      expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+    });
+
+    it('should log an error and exit when the project config is not defined', async () => {
+      getProjectConfig.mockResolvedValueOnce(null);
+      await handler({});
+
+      expect(logger.error).toHaveBeenCalledTimes(1);
+      expect(logger.error).toHaveBeenCalledWith(
+        'No project detected. Run this command from a project directory.'
+      );
+      expect(processExitSpy).toHaveBeenCalledTimes(1);
+      expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+    });
+
+    it('should log an error and exit when the project config has no projectDir', async () => {
+      getProjectConfig.mockResolvedValueOnce({ projectDir: null });
+      await handler({});
+
+      expect(logger.error).toHaveBeenCalledTimes(1);
+      expect(logger.error).toHaveBeenCalledWith(
+        'No project detected. Run this command from a project directory.'
+      );
+      expect(processExitSpy).toHaveBeenCalledTimes(1);
+      expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+    });
+
+    it('should prompt for input when packages is defined', async () => {
+      const projectDir = 'src';
+      getProjectConfig.mockResolvedValue({ projectDir });
+      const packageJsonLocation = path.join(projectDir, 'directory1');
+      promptUser.mockResolvedValueOnce(packageJsonLocation);
+      getProjectPackageJsonLocations.mockResolvedValue([packageJsonLocation]);
+      await handler({ packages: ['@hubspot/local-dev-lib'] });
+      expect(getProjectPackageJsonLocations).toHaveBeenCalledTimes(1);
+      expect(promptUser).toHaveBeenCalledTimes(1);
+      expect(promptUser).toHaveBeenCalledWith([
+        {
+          name: 'selectedInstallLocations',
+          type: 'checkbox',
+          when: expect.any(Function),
+          choices: [
+            {
+              name: 'directory1',
+              value: packageJsonLocation,
+            },
+          ],
+          message: 'Choose the project components to install the dependencies:',
+          validate: expect.any(Function),
+        },
+      ]);
+    });
+
+    it('should call installPackages correctly', async () => {
+      const projectDir = 'src';
+      const packageJsonLocation = path.join(projectDir, 'directory1');
+      const installLocations = [packageJsonLocation];
+      const packages = ['@hubspot/local-dev-lib'];
+
+      getProjectConfig.mockResolvedValue({ projectDir });
+      promptUser.mockResolvedValueOnce(packageJsonLocation);
+      getProjectPackageJsonLocations.mockResolvedValue(installLocations);
+      await handler({ packages });
+
+      expect(installPackages).toHaveBeenCalledTimes(1);
+      expect(installPackages).toHaveBeenCalledWith({
+        packages,
+        installLocations,
+      });
+    });
+  });
+});

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/cloneApp.js

@@ -42,9 +42,6 @@ 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;
@@ -138,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);
   }