@hubspot/cli 3.0.13-beta.0 → 3.0.13-beta.3

package/lib/prompts/projectsLogsPrompt.js

@@ -0,0 +1,108 @@
+const { i18n } = require('@hubspot/cli-lib/lib/lang');
+const { fetchProject } = require('@hubspot/cli-lib/api/dfs');
+const { promptUser } = require('./promptUtils');
+const { getProjectConfig, ensureProjectExists } = require('../projects');
+const { logger } = require('@hubspot/cli-lib/logger');
+const { EXIT_CODES } = require('../enums/exitCodes');
+
+const i18nKey = 'cli.lib.prompts.projectLogsPrompt';
+
+const SERVERLESS_FUNCTION_TYPES = {
+  APP_FUNCTION: 'app-function',
+  PUBLIC_ENDPOINT: 'public-endpoint',
+};
+
+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;
+
+        await ensureProjectExists(accountId, name, {
+          allowCreate: false,
+        });
+        const { deployedBuild } = await fetchProject(accountId, name);
+
+        if (deployedBuild && deployedBuild.subbuildStatuses) {
+          return deployedBuild.subbuildStatuses
+            .filter(subbuild => subbuild.buildType === 'APP')
+            .map(subbuild => ({
+              name: subbuild.buildName,
+              value: subbuild.buildName,
+            }));
+        } else {
+          logger.debug('Failed to fetch project');
+          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
+        );
+      },
+    },
+  ]);
+};
+
+module.exports = {
+  projectLogsPrompt,
+};

package/lib/serverlessLogs.js

@@ -1,5 +1,6 @@
 const https = require('https');
-
+const Spinnies = require('spinnies');
+const chalk = require('chalk');
 const { logger } = require('@hubspot/cli-lib/logger');
 const { outputLogs } = require('@hubspot/cli-lib/lib/logs');
 const {
@@ -8,18 +9,33 @@ const {
   ApiErrorContext,
 } = require('@hubspot/cli-lib/errorHandlers');
 const { base64EncodeString } = require('@hubspot/cli-lib/lib/encoding');
-const { handleKeypress } = require('@hubspot/cli-lib/lib/process');
+const { handleExit, handleKeypress } = require('@hubspot/cli-lib/lib/process');
 
 const { EXIT_CODES } = require('../lib/enums/exitCodes');
 
 const TAIL_DELAY = 5000;
 
+const handleUserInput = spinnies => {
+  const onTerminate = async () => {
+    spinnies.remove('tailLogs');
+    spinnies.remove('stopMessage');
+    process.exit(EXIT_CODES.SUCCESS);
+  };
+
+  handleExit(onTerminate);
+  handleKeypress(key => {
+    if ((key.ctrl && key.name == 'c') || key.name === 'q') {
+      onTerminate();
+    }
+  });
+};
+
 const tailLogs = async ({
   accountId,
   compact,
-  spinnies,
   fetchLatest,
   tailCall,
+  name,
 }) => {
   let initialAfter;
 
@@ -44,7 +60,6 @@ const tailLogs = async ({
       latestLog = await tailCall(after);
       nextAfter = latestLog.paging.next.after;
     } catch (e) {
-      spinnies.fail('tailLogs', { text: 'Stopped polling due to error.' });
       if (e.statusCode !== 404) {
         logApiErrorInstance(
           e,
@@ -62,18 +77,23 @@ const tailLogs = async ({
       });
     }
 
-    setTimeout(() => {
-      tail(nextAfter);
+    setTimeout(async () => {
+      await tail(nextAfter);
     }, TAIL_DELAY);
   };
 
-  handleKeypress(key => {
-    if ((key.ctrl && key.name == 'c') || key.name === 'escape') {
-      spinnies.succeed('tailLogs', { text: `Stopped polling` });
-      process.exit(EXIT_CODES.SUCCESS);
-    }
+  const spinnies = new Spinnies();
+
+  spinnies.add('tailLogs', {
+    text: `Following logs for ${name}`,
+  });
+  spinnies.add('stopMessage', {
+    text: `> Press ${chalk.bold('q')} to stop following`,
+    status: 'non-spinnable',
   });
 
+  handleUserInput(spinnies);
+
   await tail(initialAfter);
 };
 

package/lib/supportHyperlinks.js

@@ -0,0 +1,75 @@
+'use strict';
+const hasFlag = require('./hasFlag');
+
+//See https://github.com/jamestalmage/supports-hyperlinks (License: https://github.com/jamestalmage/supports-hyperlinks/blob/master/license)
+
+function parseVersion(versionString) {
+  if (/^\d{3,4}$/.test(versionString)) {
+    // Env var doesn't always use dots. example: 4601 => 46.1.0
+    const m = /(\d{1,2})(\d{2})/.exec(versionString);
+    return {
+      major: 0,
+      minor: parseInt(m[1], 10),
+      patch: parseInt(m[2], 10),
+    };
+  }
+
+  const versions = (versionString || '').split('.').map(n => parseInt(n, 10));
+  return {
+    major: versions[0],
+    minor: versions[1],
+    patch: versions[2],
+  };
+}
+
+function supportsHyperlink(stream) {
+  const { env } = process;
+
+  if (hasFlag('noHyperlinks')) {
+    return false;
+  }
+
+  if (stream && !stream.isTTY) {
+    return false;
+  }
+
+  if (process.platform === 'win32') {
+    return false;
+  }
+
+  if ('CI' in env) {
+    return false;
+  }
+
+  if ('TERM_PROGRAM' in env) {
+    const version = parseVersion(env.TERM_PROGRAM_VERSION);
+
+    switch (env.TERM_PROGRAM) {
+      case 'iTerm.app':
+        if (version.major === 3) {
+          return version.minor >= 1;
+        }
+
+        return version.major > 3;
+      // No default
+    }
+  }
+
+  if ('VTE_VERSION' in env) {
+    // 0.50.0 was supposed to support hyperlinks, but throws a segfault
+    if (env.VTE_VERSION === '0.50.0') {
+      return false;
+    }
+
+    const version = parseVersion(env.VTE_VERSION);
+    return version.major > 0 || version.minor >= 50;
+  }
+
+  return false;
+}
+
+module.exports = {
+  supportsHyperlink,
+  stdout: supportsHyperlink(process.stdout),
+  stderr: supportsHyperlink(process.stderr),
+};

package/lib/supportsColor.js

@@ -0,0 +1,129 @@
+const process = require('process');
+const os = require('os');
+const tty = require('tty');
+const hasFlag = require('./hasFlag');
+
+const { env } = process;
+
+//From: https://github.com/chalk/supports-color/blob/main/index.js (License: https://github.com/chalk/supports-color/blob/main/license)
+
+function translateLevel(level) {
+  if (level === 0) {
+    return {
+      level,
+      hasBasic: false,
+      has256: false,
+      has16m: false,
+    };
+  }
+
+  return {
+    level,
+    hasBasic: true,
+    has256: level >= 2,
+    has16m: level >= 3,
+  };
+}
+
+function _supportsColor(haveStream, { streamIsTTY } = {}) {
+  if (haveStream && !streamIsTTY) {
+    return 0;
+  }
+
+  const min = 0;
+
+  if (env.TERM === 'dumb') {
+    return min;
+  }
+
+  if (hasFlag('noColor')) {
+    return 0;
+  }
+
+  if (process.platform === 'win32') {
+    // Windows 10 build 10586 is the first Windows release that supports 256 colors.
+    // Windows 10 build 14931 is the first release that supports 16m/TrueColor.
+    const osRelease = os.release().split('.');
+    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+      return Number(osRelease[2]) >= 14931 ? 3 : 2;
+    }
+
+    return 1;
+  }
+
+  if ('CI' in env) {
+    if (
+      [
+        'TRAVIS',
+        'CIRCLECI',
+        'APPVEYOR',
+        'GITLAB_CI',
+        'GITHUB_ACTIONS',
+        'BUILDKITE',
+        'DRONE',
+      ].some(sign => sign in env) ||
+      env.CI_NAME === 'codeship'
+    ) {
+      return 1;
+    }
+
+    return min;
+  }
+
+  // Check for Azure DevOps pipelines
+  if ('TF_BUILD' in env && 'AGENT_NAME' in env) {
+    return 1;
+  }
+
+  if (env.COLORTERM === 'truecolor') {
+    return 3;
+  }
+
+  if ('TERM_PROGRAM' in env) {
+    const version = Number.parseInt(
+      (env.TERM_PROGRAM_VERSION || '').split('.')[0],
+      10
+    );
+
+    switch (env.TERM_PROGRAM) {
+      case 'iTerm.app':
+        return version >= 3 ? 3 : 2;
+      case 'Apple_Terminal':
+        return 2;
+      // No default
+    }
+  }
+
+  if (/-256(color)?$/i.test(env.TERM)) {
+    return 2;
+  }
+
+  if (
+    /^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)
+  ) {
+    return 1;
+  }
+
+  if ('COLORTERM' in env) {
+    return 1;
+  }
+
+  return min;
+}
+
+function createSupportsColor(stream, options = {}) {
+  const level = _supportsColor(stream, {
+    streamIsTTY: stream && stream.isTTY,
+    ...options,
+  });
+
+  return translateLevel(level);
+}
+
+const supportsColor = {
+  createSupportsColor,
+  stdout: createSupportsColor({ isTTY: tty.isatty(1) }),
+  stderr: createSupportsColor({ isTTY: tty.isatty(2) }),
+};
+
+module.exports = supportsColor;

package/lib/ui.js

@@ -1,5 +1,6 @@
 const chalk = require('chalk');
-const supportsHyperlinks = require('supports-hyperlinks');
+const supportsHyperlinks = require('../lib/supportHyperlinks');
+const supportsColor = require('../lib/supportsColor');
 const { getAccountConfig } = require('@hubspot/cli-lib/lib/config');
 const { logger } = require('@hubspot/cli-lib/logger');
 
@@ -12,6 +13,19 @@ const uiLine = () => {
   logger.log('-'.repeat(50));
 };
 
+/**
+ * Returns an object that aggregates what the terminal supports (eg. hyperlinks and color)
+ *
+ * @returns {object}
+ */
+
+const getTerminalUISupport = () => {
+  return {
+    hyperlinks: supportsHyperlinks.stdout,
+    color: supportsColor.stdout.hasBasic,
+  };
+};
+
 /**
  * Returns a hyperlink or link and description
  *
@@ -20,8 +34,9 @@ const uiLine = () => {
  * @param {object} options
  * @returns {string}
  */
-const uiLink = (linkText, url, options = {}) => {
-  if (supportsHyperlinks.stdout) {
+const uiLink = (linkText, url) => {
+  const terminalUISupport = getTerminalUISupport();
+  if (terminalUISupport.hyperlinks) {
     const result = [
       '\u001B]8;;',
       url,
@@ -29,9 +44,11 @@ const uiLink = (linkText, url, options = {}) => {
       linkText,
       '\u001B]8;;\u0007',
     ].join('');
-    return options.useColor ? chalk.cyan(result) : result;
+    return terminalUISupport.color ? chalk.cyan(result) : result;
   } else {
-    return options.fallback ? `${linkText}: ${url}` : linkText;
+    return terminalUISupport.color
+      ? `${linkText}: ${chalk.cyan(url)}`
+      : `${linkText}: ${url}`;
   }
 };
 

package/lib/validators/__tests__/{BaseValidator.js → AbsoluteValidator.js}

@@ -1,12 +1,12 @@
-const BaseValidator = require('../marketplaceValidators/BaseValidator');
+const AbsoluteValidator = require('../marketplaceValidators/AbsoluteValidator');
 const { VALIDATION_RESULT } = require('../constants');
 
-const Validator = new BaseValidator({
+const Validator = new AbsoluteValidator({
   name: 'Test validator',
   key: 'validatorKey',
 });
 
-describe('validators/marketplaceValidators/BaseValidator', () => {
+describe('validators/marketplaceValidators/AbsoluteValidator', () => {
   it('getSuccess returns expected object', async () => {
     const success = Validator.getSuccess();
 

package/lib/validators/__tests__/ModuleDependencyValidator.js

@@ -0,0 +1,79 @@
+const marketplace = require('@hubspot/cli-lib/api/marketplace');
+const path = require('path');
+
+const ModuleDependencyValidator = require('../marketplaceValidators/module/ModuleDependencyValidator');
+const { VALIDATION_RESULT } = require('../constants');
+const { MODULE_PATH } = require('./validatorTestUtils');
+
+jest.mock('@hubspot/cli-lib/api/marketplace');
+
+const getMockDependencyResult = (customPaths = []) => {
+  const result = {
+    dependencies: [...customPaths],
+  };
+  return Promise.resolve(result);
+};
+
+describe('validators/marketplaceValidators/module/ModuleDependencyValidator', () => {
+  beforeEach(() => {
+    ModuleDependencyValidator.setRelativePath(MODULE_PATH);
+  });
+
+  describe('isExternalDep', () => {
+    beforeEach(() => {
+      ModuleDependencyValidator.setRelativePath(MODULE_PATH);
+    });
+
+    it('returns true if dep is external to the provided absolute path', () => {
+      const isExternal = ModuleDependencyValidator.isExternalDep(
+        MODULE_PATH,
+        'SomeOtherFolder/In/The/DesignManager.css'
+      );
+      expect(isExternal).toBe(true);
+    });
+
+    it('returns false if dep is not external to the provided absolute path', () => {
+      const isExternal = ModuleDependencyValidator.isExternalDep(
+        MODULE_PATH,
+        `${path.parse(MODULE_PATH).dir}/Internal/Folder/style.css`
+      );
+      expect(isExternal).toBe(false);
+    });
+  });
+
+  describe('validate', () => {
+    it('returns error if any referenced path is absolute', async () => {
+      marketplace.fetchModuleDependencies.mockReturnValue(
+        getMockDependencyResult(['/absolute/path'])
+      );
+      const validationErrors = await ModuleDependencyValidator.validate(
+        MODULE_PATH
+      );
+
+      expect(validationErrors.length).toBe(1);
+      expect(validationErrors[0].result).toBe(VALIDATION_RESULT.FATAL);
+    });
+
+    it('returns error if any referenced path is external to the theme', async () => {
+      marketplace.fetchModuleDependencies.mockReturnValue(
+        getMockDependencyResult(['../../external/file-3.js'])
+      );
+      const validationErrors = await ModuleDependencyValidator.validate(
+        MODULE_PATH
+      );
+
+      expect(validationErrors.length).toBe(1);
+      expect(validationErrors[0].result).toBe(VALIDATION_RESULT.FATAL);
+    });
+
+    it('returns no errors if paths are relative and internal', async () => {
+      marketplace.fetchModuleDependencies.mockReturnValue(
+        getMockDependencyResult(['module/style.css', 'module/another/test.js'])
+      );
+      const validationErrors = await ModuleDependencyValidator.validate(
+        MODULE_PATH
+      );
+      expect(validationErrors.length).toBe(0);
+    });
+  });
+});

package/lib/validators/__tests__/ModuleValidator.js

@@ -1,84 +1,51 @@
-const fs = require('fs');
-const ModuleValidator = require('../marketplaceValidators/theme/ModuleValidator');
+const ModuleValidator = require('../marketplaceValidators/module/ModuleValidator');
 const { VALIDATION_RESULT } = require('../constants');
-const {
-  generateModulesList,
-  makeFindError,
-  THEME_PATH,
-} = require('./validatorTestUtils');
+const { MODULE_PATH } = require('./validatorTestUtils');
+const marketplace = require('@hubspot/cli-lib/api/marketplace');
 
-jest.mock('fs');
+jest.mock('@hubspot/cli-lib/api/marketplace');
 
-const MODULE_LIMIT = 50;
-
-const findError = makeFindError('module');
-
-describe('validators/marketplaceValidators/theme/ModuleValidator', () => {
+describe('validators/marketplaceValidators/module/ModuleValidator', () => {
   beforeEach(() => {
-    ModuleValidator.setThemePath(THEME_PATH);
-  });
-
-  it('returns error if module limit is exceeded', async () => {
-    const validationErrors = ModuleValidator.validate(
-      generateModulesList(MODULE_LIMIT + 1)
-    );
-    const limitError = findError(validationErrors, 'limitExceeded');
-    expect(limitError).toBeDefined();
-    expect(limitError.result).toBe(VALIDATION_RESULT.FATAL);
-  });
-
-  it('returns no limit error if module limit is not exceeded', async () => {
-    const validationErrors = ModuleValidator.validate(
-      generateModulesList(MODULE_LIMIT)
-    );
-    const limitError = findError(validationErrors, 'limitExceeded');
-    expect(limitError).not.toBeDefined();
-  });
-
-  it('returns error if no module meta.json file exists', async () => {
-    const validationErrors = ModuleValidator.validate([
-      'module.module/module.html',
-    ]);
-    expect(validationErrors.length).toBe(1);
-    expect(validationErrors[0].result).toBe(VALIDATION_RESULT.FATAL);
+    ModuleValidator.setRelativePath(MODULE_PATH);
   });
 
   it('returns error if module meta.json file has invalid json', async () => {
-    fs.readFileSync.mockReturnValue('{} bad json }');
+    marketplace.fetchModuleMeta.mockReturnValue(
+      Promise.resolve({ source: '{} bad json }' })
+    );
 
-    const validationErrors = ModuleValidator.validate([
-      'module.module/meta.json',
-    ]);
+    const validationErrors = await ModuleValidator.validate(MODULE_PATH);
     expect(validationErrors.length).toBe(1);
     expect(validationErrors[0].result).toBe(VALIDATION_RESULT.FATAL);
   });
 
   it('returns error if module meta.json file is missing a label field', async () => {
-    fs.readFileSync.mockReturnValue('{ "icon": "woo" }');
+    marketplace.fetchModuleMeta.mockReturnValue(
+      Promise.resolve({ source: '{ "icon": "woo" }' })
+    );
 
-    const validationErrors = ModuleValidator.validate([
-      'module.module/meta.json',
-    ]);
+    const validationErrors = await ModuleValidator.validate(MODULE_PATH);
     expect(validationErrors.length).toBe(1);
     expect(validationErrors[0].result).toBe(VALIDATION_RESULT.FATAL);
   });
 
   it('returns error if module meta.json file is missing an icon field', async () => {
-    fs.readFileSync.mockReturnValue('{ "label": "yay" }');
+    marketplace.fetchModuleMeta.mockReturnValue(
+      Promise.resolve({ source: '{ "label": "yay" }' })
+    );
 
-    const validationErrors = ModuleValidator.validate([
-      'module.module/meta.json',
-    ]);
+    const validationErrors = await ModuleValidator.validate(MODULE_PATH);
     expect(validationErrors.length).toBe(1);
     expect(validationErrors[0].result).toBe(VALIDATION_RESULT.FATAL);
   });
 
   it('returns no error if module meta.json file exists and has all required fields', async () => {
-    fs.readFileSync.mockReturnValue('{ "label": "yay", "icon": "woo" }');
+    marketplace.fetchModuleMeta.mockReturnValue(
+      Promise.resolve({ source: '{ "label": "yay", "icon": "woo" }' })
+    );
 
-    const validationErrors = ModuleValidator.validate([
-      'module.module/meta.json',
-    ]);
+    const validationErrors = await ModuleValidator.validate(MODULE_PATH);
     expect(validationErrors.length).toBe(0);
   });
 });

package/lib/validators/__tests__/RelativeValidator.js

@@ -0,0 +1,28 @@
+const RelativeValidator = require('../marketplaceValidators/RelativeValidator');
+const { VALIDATION_RESULT } = require('../constants');
+
+const Validator = new RelativeValidator({
+  name: 'Test validator',
+  key: 'validatorKey',
+});
+
+describe('validators/marketplaceValidators/RelativeValidator', () => {
+  it('getSuccess returns expected object', async () => {
+    const success = Validator.getSuccess();
+
+    expect(success.validatorKey).toBe('validatorKey');
+    expect(success.validatorName).toBe('Test validator');
+    expect(success.result).toBe(VALIDATION_RESULT.SUCCESS);
+  });
+
+  it('getError returns expected object', async () => {
+    const errorObj = { key: 'errorkey', getCopy: () => 'Some error copy' };
+    const success = Validator.getError(errorObj);
+
+    expect(success.validatorKey).toBe('validatorKey');
+    expect(success.validatorName).toBe('Test validator');
+    expect(success.error).toBe('Some error copy');
+    expect(success.result).toBe(VALIDATION_RESULT.FATAL);
+    expect(success.key).toBe('validatorKey.errorkey');
+  });
+});

package/lib/validators/__tests__/TemplateValidator.js

@@ -29,7 +29,7 @@ const findError = makeFindError('template');
 
 describe('validators/marketplaceValidators/theme/TemplateValidator', () => {
   beforeEach(() => {
-    TemplateValidator.setThemePath(THEME_PATH);
+    TemplateValidator.setAbsolutePath(THEME_PATH);
     templates.isCodedFile.mockReturnValue(true);
   });