@hubspot/cli 5.3.1 → 5.4.1-beta.0

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

@@ -7,6 +7,7 @@ const findup = require('findup-sync');
 const { logger } = require('@hubspot/local-dev-lib/logger');
 const { getEnv } = require('@hubspot/local-dev-lib/config');
 const { getHubSpotWebsiteOrigin } = require('@hubspot/local-dev-lib/urls');
+const { fetchFileFromRepository } = require('@hubspot/local-dev-lib/github');
 const {
   ENVIRONMENTS,
 } = require('@hubspot/local-dev-lib/constants/environments');
@@ -18,6 +19,8 @@ const {
   PROJECT_CONFIG_FILE,
   PROJECT_TASK_TYPES,
   PROJECT_ERROR_TYPES,
+  HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH,
+  PROJECT_COMPONENT_TYPES,
 } = require('./constants');
 const {
   createProject,
@@ -46,7 +49,6 @@ const {
   logApiErrorInstance,
   ApiErrorContext,
 } = require('./errorHandlers/apiErrors');
-const { HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH } = require('./constants');
 
 const i18nKey = 'lib.projects';
 
@@ -285,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) {
@@ -310,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);
   }
 };
@@ -570,7 +569,7 @@ const handleProjectUpload = async (
           buildId
         );
       }
-      resolve(uploadResult);
+      resolve(uploadResult || {});
     })
   );
 
@@ -1002,6 +1001,16 @@ const displayWarnLogs = async (
   }
 };
 
+const getProjectComponentsByVersion = async projectComponentsVersion => {
+  const config = await fetchFileFromRepository(
+    HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH,
+    'config.json',
+    projectComponentsVersion
+  );
+
+  return config[PROJECT_COMPONENT_TYPES.COMPONENTS];
+};
+
 module.exports = {
   writeProjectConfig,
   getProjectConfig,
@@ -1019,4 +1028,5 @@ module.exports = {
   logFeedbackMessage,
   createProjectComponent,
   displayWarnLogs,
+  getProjectComponentsByVersion,
 };

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

@@ -1,32 +1,15 @@
 const { promptUser } = require('./promptUtils');
-const { fetchFileFromRepository } = require('@hubspot/local-dev-lib/github');
 const { i18n } = require('../lang');
-const { HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH } = require('../constants');
-const { PROJECT_COMPONENT_TYPES } = require('../constants');
 
 const i18nKey = 'lib.prompts.projectAddPrompt';
 
-const createTypeOptions = async projectComponentsVersion => {
-  const config = await fetchFileFromRepository(
-    HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH,
-    'config.json',
-    projectComponentsVersion
-  );
-
-  return config[PROJECT_COMPONENT_TYPES.COMPONENTS];
-};
-
-const projectAddPrompt = async (
-  projectComponentsVersion,
-  promptOptions = {}
-) => {
-  const components = await createTypeOptions(projectComponentsVersion);
+const projectAddPrompt = async (components, promptOptions = {}) => {
   return promptUser([
     {
-      name: 'type',
+      name: 'component',
       message: () => {
         return promptOptions.type &&
-          !components.find(t => t.path === promptOptions.type.path)
+          !components.find(t => t.path === promptOptions.type)
           ? i18n(`${i18nKey}.errors.invalidType`, {
               type: promptOptions.type,
             })
@@ -34,7 +17,7 @@ const projectAddPrompt = async (
       },
       when:
         !promptOptions.type ||
-        !components.find(t => t.path === promptOptions.type.path),
+        !components.find(t => t.path === promptOptions.type),
       type: 'list',
       choices: components.map(type => {
         return {

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: {

package/lib/prompts/projectsLogsPrompt.js

@@ -1,120 +1,29 @@
 const { i18n } = require('../lang');
-const { fetchProject } = require('@hubspot/local-dev-lib/api/projects');
 const { promptUser } = require('./promptUtils');
-const { getAccountId } = require('../commonOpts');
-const { getProjectConfig, ensureProjectExists } = require('../projects');
-const {
-  logApiErrorInstance,
-  ApiErrorContext,
-} = require('../../lib/errorHandlers/apiErrors');
-const { logger } = require('@hubspot/local-dev-lib/logger');
-const { EXIT_CODES } = require('../enums/exitCodes');
 
 const i18nKey = 'lib.prompts.projectLogsPrompt';
 
-const SERVERLESS_FUNCTION_TYPES = {
-  APP_FUNCTION: 'app-function',
-  PUBLIC_ENDPOINT: 'public-endpoint',
-};
+const projectLogsPrompt = async ({
+  functionChoices,
+  promptOptions,
+  projectName = {},
+}) => {
+  if (!functionChoices) {
+    return {};
+  }
+  if (functionChoices && functionChoices.length === 1) {
+    return { functionName: functionChoices[0] };
+  }
 
-const projectLogsPrompt = (accountId, promptOptions = {}) => {
   return promptUser([
-    {
-      name: 'projectName',
-      message: i18n(`${i18nKey}.projectName.message`),
-      when: !promptOptions.project,
-      default: async () => {
-        const { projectConfig } = await getProjectConfig();
-        return projectConfig && projectConfig.name ? projectConfig.name : null;
-      },
-      validate: name =>
-        !name.length ? i18n(`${i18nKey}.projectName.error`) : true,
-    },
-    {
-      name: 'logType',
-      type: 'list',
-      message: i18n(`${i18nKey}.logType.message`),
-      when:
-        !promptOptions.app &&
-        !promptOptions.function &&
-        !promptOptions.endpoint,
-      choices: [
-        {
-          name: i18n(`${i18nKey}.logType.function`),
-          value: SERVERLESS_FUNCTION_TYPES.APP_FUNCTION,
-        },
-        {
-          name: i18n(`${i18nKey}.logType.endpoint`),
-          value: SERVERLESS_FUNCTION_TYPES.PUBLIC_ENDPOINT,
-        },
-      ],
-    },
-    {
-      name: 'appName',
-      type: 'list',
-      message: i18n(`${i18nKey}.appName`),
-      when: ({ logType }) => {
-        return (
-          (promptOptions.function ||
-            logType === SERVERLESS_FUNCTION_TYPES.APP_FUNCTION) &&
-          !promptOptions.app &&
-          !promptOptions.endpoint
-        );
-      },
-      choices: async ({ projectName }) => {
-        const name = projectName || promptOptions.project;
-
-        try {
-          await ensureProjectExists(accountId, name, {
-            allowCreate: false,
-          });
-          const { deployedBuild } = await fetchProject(accountId, name);
-
-          if (deployedBuild && deployedBuild.subbuildStatuses) {
-            return deployedBuild.subbuildStatuses
-              .filter(subbuild => subbuild.buildType === 'PRIVATE_APP')
-              .map(subbuild => ({
-                name: subbuild.buildName,
-                value: subbuild.buildName,
-              }));
-          } else {
-            logger.debug('Failed to fetch project');
-            process.exit(EXIT_CODES.ERROR);
-          }
-        } catch (e) {
-          const { projectConfig } = await getProjectConfig();
-          const projectName = projectConfig.name;
-
-          logApiErrorInstance(
-            e,
-            new ApiErrorContext({ accountId: getAccountId(), projectName })
-          );
-          process.exit(EXIT_CODES.ERROR);
-        }
-      },
-    },
     {
       name: 'functionName',
-      message: i18n(`${i18nKey}.functionName`),
-      when: ({ logType }) => {
-        return (
-          (promptOptions.app ||
-            logType === SERVERLESS_FUNCTION_TYPES.APP_FUNCTION) &&
-          !promptOptions.function &&
-          !promptOptions.endpoint
-        );
-      },
-    },
-    {
-      name: 'endpointName',
-      message: i18n(`${i18nKey}.endpointName`),
-      when: ({ logType }) => {
-        return (
-          logType === SERVERLESS_FUNCTION_TYPES.PUBLIC_ENDPOINT &&
-          !promptOptions.function &&
-          !promptOptions.endpoint
-        );
-      },
+      type: 'list',
+      message: i18n(`${i18nKey}.functionName`, { projectName }),
+      when: () =>
+        (!promptOptions || !promptOptions.function) &&
+        functionChoices.length > 0,
+      choices: functionChoices,
     },
   ]);
 };

package/lib/sandboxSync.js

@@ -4,14 +4,12 @@ const { logger } = require('@hubspot/local-dev-lib/logger');
 const { i18n } = require('./lang');
 const { getAvailableSyncTypes } = require('./sandboxes');
 const { initiateSync } = require('@hubspot/local-dev-lib/sandboxes');
+const { debugErrorAndContext } = require('./errorHandlers/standardErrors');
 const {
-  debugErrorAndContext,
-  logErrorInstance,
-} = require('./errorHandlers/standardErrors');
-const {
-  isSpecifiedError,
-  isMissingScopeError,
-} = require('@hubspot/local-dev-lib/errors/apiErrors');
+  logApiErrorInstance,
+  ApiErrorContext,
+} = require('./errorHandlers/apiErrors');
+const { isSpecifiedError } = require('@hubspot/local-dev-lib/errors/apiErrors');
 const { getSandboxTypeAsString } = require('./sandboxes');
 const { getAccountId } = require('@hubspot/local-dev-lib/config');
 const {
@@ -97,13 +95,7 @@ const syncSandbox = async ({
     });
 
     logger.log('');
-    if (isMissingScopeError(err)) {
-      logger.error(
-        i18n(`${i18nKey}.failure.missingScopes`, {
-          accountName: uiAccountDescription(parentAccountId),
-        })
-      );
-    } else if (
+    if (
       isSpecifiedError(err, {
         statusCode: 403,
         category: 'BANNED',
@@ -163,7 +155,13 @@ const syncSandbox = async ({
         'https://app.hubspot.com/l/docs/guides/crm/project-cli-commands#developer-projects-cli-commands-beta'
       );
     } else {
-      logErrorInstance(err);
+      logApiErrorInstance(
+        err,
+        new ApiErrorContext({
+          accountId: parentAccountId,
+          request: 'sandbox sync',
+        })
+      );
     }
     logger.log('');
     throw err;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hubspot/cli",
-  "version": "5.3.1",
+  "version": "5.4.1-beta.0",
   "description": "CLI for working with HubSpot",
   "license": "Apache-2.0",
   "repository": {
@@ -8,10 +8,10 @@
     "url": "https://github.com/HubSpot/hubspot-cms-tools"
   },
   "dependencies": {
-    "@hubspot/local-dev-lib": "1.10.0",
-    "@hubspot/serverless-dev-runtime": "5.3.0",
+    "@hubspot/local-dev-lib": "1.13.0",
+    "@hubspot/serverless-dev-runtime": "5.4.1-beta.0",
     "@hubspot/theme-preview-dev-server": "0.0.7",
-    "@hubspot/ui-extensions-dev-server": "0.8.20",
+    "@hubspot/ui-extensions-dev-server": "0.8.33",
     "archiver": "^5.3.0",
     "chalk": "^4.1.2",
     "chokidar": "^3.0.1",
@@ -37,7 +37,7 @@
     "mock-stdin": "^1.0.0"
   },
   "engines": {
-    "node": ">=16"
+    "node": ">=18"
   },
   "bin": {
     "hs": "./bin/hs",
@@ -46,5 +46,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "f66f8d19cc041132fb985b56156eed2511d9a588"
+  "gitHead": "bce14e5b832d387f2d1166a587c57f50242a65d7"
 }