@hubspot/cli 3.0.13-beta.1 → 3.0.13-beta.2

package/bin/cli.js

@@ -31,6 +31,7 @@ const openCommand = require('../commands/open');
 const mvCommand = require('../commands/mv');
 const projectCommands = require('../commands/project');
 const themeCommand = require('../commands/theme');
+const moduleCommand = require('../commands/module');
 const configCommand = require('../commands/config');
 const accountsCommand = require('../commands/accounts');
 const sandboxesCommand = require('../commands/sandbox');
@@ -120,6 +121,7 @@ const argv = yargs
   .command(mvCommand)
   .command(projectCommands)
   .command(themeCommand)
+  .command(moduleCommand)
   .command(configCommand)
   .command(accountsCommand)
   .command(sandboxesCommand)

package/commands/module/marketplace-validate.js

@@ -0,0 +1,77 @@
+const { logger } = require('@hubspot/cli-lib/logger');
+
+const {
+  addConfigOptions,
+  addAccountOptions,
+  addUseEnvironmentOptions,
+  getAccountId,
+} = require('../../lib/commonOpts');
+const { loadAndValidateOptions } = require('../../lib/validation');
+const { trackCommandUsage } = require('../../lib/usageTracking');
+const {
+  logValidatorResults,
+} = require('../../lib/validators/logValidatorResults');
+const {
+  applyRelativeValidators,
+} = require('../../lib/validators/applyValidators');
+const MARKETPLACE_VALIDATORS = require('../../lib/validators');
+const { VALIDATION_RESULT } = require('../../lib/validators/constants');
+const { i18n } = require('@hubspot/cli-lib/lib/lang');
+
+const i18nKey = 'cli.commands.module.subcommands.marketplaceValidate';
+const { EXIT_CODES } = require('../../lib/enums/exitCodes');
+
+exports.command = 'marketplace-validate <src>';
+exports.describe = i18n(`${i18nKey}.describe`);
+
+exports.handler = async options => {
+  const { src } = options;
+
+  await loadAndValidateOptions(options);
+
+  const accountId = getAccountId(options);
+
+  if (!options.json) {
+    logger.log(
+      i18n(`${i18nKey}.logs.validatingModule`, {
+        path: src,
+      })
+    );
+  }
+  trackCommandUsage('validate', {}, accountId);
+
+  applyRelativeValidators(
+    MARKETPLACE_VALIDATORS.module,
+    src,
+    src,
+    accountId
+  ).then(groupedResults => {
+    logValidatorResults(groupedResults, { logAsJson: options.json });
+
+    if (
+      groupedResults
+        .flat()
+        .some(result => result.result === VALIDATION_RESULT.FATAL)
+    ) {
+      process.exit(EXIT_CODES.WARNING);
+    }
+  });
+};
+
+exports.builder = yargs => {
+  addConfigOptions(yargs, true);
+  addAccountOptions(yargs, true);
+  addUseEnvironmentOptions(yargs, true);
+
+  yargs.options({
+    json: {
+      describe: i18n(`${i18nKey}.options.json.describe`),
+      type: 'boolean',
+    },
+  });
+  yargs.positional('src', {
+    describe: i18n(`${i18nKey}.positionals.src.describe`),
+    type: 'string',
+  });
+  return yargs;
+};

package/commands/module.js

@@ -0,0 +1,17 @@
+const marketplaceValidate = require('./module/marketplace-validate');
+const { addConfigOptions, addAccountOptions } = require('../lib/commonOpts');
+// const { i18n } = require('@hubspot/cli-lib/lib/lang');
+
+// const i18nKey = 'cli.commands.module';
+
+exports.command = 'module';
+exports.describe = false; //i18n(`${i18nKey}.describe`);
+
+exports.builder = yargs => {
+  addConfigOptions(yargs, true);
+  addAccountOptions(yargs, true);
+
+  yargs.command(marketplaceValidate).demandCommand(1, '');
+
+  return yargs;
+};

package/commands/theme/marketplace-validate.js

@@ -16,7 +16,9 @@ const { trackCommandUsage } = require('../../lib/usageTracking');
 const {
   logValidatorResults,
 } = require('../../lib/validators/logValidatorResults');
-const { applyValidators } = require('../../lib/validators/applyValidators');
+const {
+  applyAbsoluteValidators,
+} = require('../../lib/validators/applyValidators');
 const MARKETPLACE_VALIDATORS = require('../../lib/validators');
 const { VALIDATION_RESULT } = require('../../lib/validators/constants');
 const { i18n } = require('@hubspot/cli-lib/lib/lang');
@@ -65,7 +67,7 @@ exports.handler = async options => {
 
   const themeFiles = await walk(absoluteSrcPath);
 
-  applyValidators(
+  applyAbsoluteValidators(
     MARKETPLACE_VALIDATORS.theme,
     absoluteSrcPath,
     themeFiles,

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);
   });
 

package/lib/validators/__tests__/ThemeConfigValidator.js

@@ -10,7 +10,7 @@ jest.mock('path');
 
 describe('validators/marketplaceValidators/theme/ThemeConfigValidator', () => {
   beforeEach(() => {
-    ThemeConfigValidator.setThemePath(THEME_PATH);
+    ThemeConfigValidator.setAbsolutePath(THEME_PATH);
   });
 
   it('returns error if no theme.json file exists', async () => {

package/lib/validators/__tests__/{DependencyValidator.js → ThemeDependencyValidator.js}

@@ -1,7 +1,7 @@
 const fs = require('fs-extra');
 const marketplace = require('@hubspot/cli-lib/api/marketplace');
 
-const DependencyValidator = require('../marketplaceValidators/theme/DependencyValidator');
+const ThemeDependencyValidator = require('../marketplaceValidators/theme/ThemeDependencyValidator');
 const { VALIDATION_RESULT } = require('../constants');
 const { THEME_PATH } = require('./validatorTestUtils');
 
@@ -15,20 +15,20 @@ const getMockDependencyResult = (customPaths = []) => {
   return Promise.resolve(result);
 };
 
-describe('validators/marketplaceValidators/theme/DependencyValidator', () => {
+describe('validators/marketplaceValidators/theme/ThemeDependencyValidator', () => {
   beforeEach(() => {
-    DependencyValidator.setThemePath(THEME_PATH);
+    ThemeDependencyValidator.setAbsolutePath(THEME_PATH);
   });
 
   describe('isExternalDep', () => {
     beforeEach(() => {
-      DependencyValidator.setThemePath(THEME_PATH);
+      ThemeDependencyValidator.setAbsolutePath(THEME_PATH);
     });
 
     it('returns true if dep is external to the provided absolute path', () => {
       const absoluteFilePath = `${THEME_PATH}/file.js`;
       const relativeDepPath = '../external/dep/path/file2.js';
-      const isExternal = DependencyValidator.isExternalDep(
+      const isExternal = ThemeDependencyValidator.isExternalDep(
         absoluteFilePath,
         relativeDepPath
       );
@@ -38,7 +38,7 @@ describe('validators/marketplaceValidators/theme/DependencyValidator', () => {
     it('returns false if dep is not external to the provided absolute path', () => {
       const absoluteFilePath = `${THEME_PATH}/file.js`;
       const relativeDepPath = './internal/dep/path/file2.js';
-      const isExternal = DependencyValidator.isExternalDep(
+      const isExternal = ThemeDependencyValidator.isExternalDep(
         absoluteFilePath,
         relativeDepPath
       );
@@ -52,10 +52,10 @@ describe('validators/marketplaceValidators/theme/DependencyValidator', () => {
     });
 
     it('returns error if any referenced path is absolute', async () => {
-      marketplace.fetchDependencies.mockReturnValue(
+      marketplace.fetchTemplateDependencies.mockReturnValue(
         getMockDependencyResult(['/absolute/file-3.js'])
       );
-      const validationErrors = await DependencyValidator.validate([
+      const validationErrors = await ThemeDependencyValidator.validate([
         `${THEME_PATH}/template.html`,
       ]);
 
@@ -64,10 +64,10 @@ describe('validators/marketplaceValidators/theme/DependencyValidator', () => {
     });
 
     it('returns error if any referenced path is external to the theme', async () => {
-      marketplace.fetchDependencies.mockReturnValue(
+      marketplace.fetchTemplateDependencies.mockReturnValue(
         getMockDependencyResult(['../../external/file-3.js'])
       );
-      const validationErrors = await DependencyValidator.validate([
+      const validationErrors = await ThemeDependencyValidator.validate([
         `${THEME_PATH}/template.html`,
       ]);
 
@@ -76,8 +76,10 @@ describe('validators/marketplaceValidators/theme/DependencyValidator', () => {
     });
 
     it('returns no errors if paths are relative and internal', async () => {
-      marketplace.fetchDependencies.mockReturnValue(getMockDependencyResult());
-      const validationErrors = await DependencyValidator.validate([
+      marketplace.fetchTemplateDependencies.mockReturnValue(
+        getMockDependencyResult()
+      );
+      const validationErrors = await ThemeDependencyValidator.validate([
         `${THEME_PATH}/template.html`,
       ]);
 

package/lib/validators/__tests__/ThemeModuleValidator.js

@@ -0,0 +1,84 @@
+const fs = require('fs');
+const ThemeModuleValidator = require('../marketplaceValidators/theme/ThemeModuleValidator');
+const { VALIDATION_RESULT } = require('../constants');
+const {
+  generateModulesList,
+  makeFindError,
+  THEME_PATH,
+} = require('./validatorTestUtils');
+
+jest.mock('fs');
+
+const MODULE_LIMIT = 50;
+
+const findError = makeFindError('themeModule');
+
+describe('validators/marketplaceValidators/theme/ThemeModuleValidator', () => {
+  beforeEach(() => {
+    ThemeModuleValidator.setAbsolutePath(THEME_PATH);
+  });
+
+  it('returns error if module limit is exceeded', async () => {
+    const validationErrors = ThemeModuleValidator.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 = ThemeModuleValidator.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 = ThemeModuleValidator.validate([
+      'module.module/module.html',
+    ]);
+    expect(validationErrors.length).toBe(1);
+    expect(validationErrors[0].result).toBe(VALIDATION_RESULT.FATAL);
+  });
+
+  it('returns error if module meta.json file has invalid json', async () => {
+    fs.readFileSync.mockReturnValue('{} bad json }');
+
+    const validationErrors = ThemeModuleValidator.validate([
+      'module.module/meta.json',
+    ]);
+    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" }');
+
+    const validationErrors = ThemeModuleValidator.validate([
+      'module.module/meta.json',
+    ]);
+    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" }');
+
+    const validationErrors = ThemeModuleValidator.validate([
+      'module.module/meta.json',
+    ]);
+    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" }');
+
+    const validationErrors = ThemeModuleValidator.validate([
+      'module.module/meta.json',
+    ]);
+    expect(validationErrors.length).toBe(0);
+  });
+});

package/lib/validators/__tests__/validatorTestUtils.js

@@ -2,6 +2,7 @@
 test.skip('skip', () => null);
 
 const THEME_PATH = '/path/to/a/theme';
+const MODULE_PATH = 'module/path';
 
 const makeFindError = baseKey => (errors, errorKey) =>
   errors.find(error => error.key === `${baseKey}.${errorKey}`);
@@ -31,4 +32,5 @@ module.exports = {
   generateTemplatesList,
   makeFindError,
   THEME_PATH,
+  MODULE_PATH,
 };

package/lib/validators/applyValidators.js

@@ -1,9 +1,9 @@
-async function applyValidators(validators, absoluteThemePath, ...args) {
+async function applyAbsoluteValidators(validators, absolutePath, ...args) {
   return Promise.all(
     validators.map(async Validator => {
-      Validator.setThemePath(absoluteThemePath);
+      Validator.setAbsolutePath(absolutePath);
       const validationResult = await Validator.validate(...args);
-      Validator.clearThemePath();
+      Validator.clearAbsolutePath();
 
       if (!validationResult.length) {
         // Return a success obj so we can log the successes
@@ -14,4 +14,20 @@ async function applyValidators(validators, absoluteThemePath, ...args) {
   );
 }
 
-module.exports = { applyValidators };
+async function applyRelativeValidators(validators, relativePath, ...args) {
+  return Promise.all(
+    validators.map(async Validator => {
+      Validator.setRelativePath(relativePath);
+      const validationResult = await Validator.validate(...args);
+      Validator.clearRelativePath();
+
+      if (!validationResult.length) {
+        // Return a success obj so we can log the successes
+        return [Validator.getSuccess()];
+      }
+      return validationResult;
+    })
+  );
+}
+
+module.exports = { applyAbsoluteValidators, applyRelativeValidators };

package/lib/validators/constants.js

@@ -4,11 +4,13 @@ const SUCCESS = 'SUCCESS';
 
 const VALIDATION_RESULT = { WARNING, FATAL, SUCCESS };
 const VALIDATOR_KEYS = {
-  dependency: 'dependency',
-  module: 'module',
+  themeDependency: 'themeDependency',
+  themeModule: 'themeModule',
   section: 'section',
   template: 'template',
   themeConfig: 'themeConfig',
+  module: 'module',
+  moduleDependency: 'moduleDependency',
 };
 
 module.exports = { VALIDATOR_KEYS, VALIDATION_RESULT };

package/lib/validators/index.js

@@ -1,17 +1,21 @@
 const ThemeConfigValidator = require('./marketplaceValidators/theme/ThemeConfigValidator');
 const SectionValidator = require('./marketplaceValidators/theme/SectionValidator');
 const TemplateValidator = require('./marketplaceValidators/theme/TemplateValidator');
-const ModuleValidator = require('./marketplaceValidators/theme/ModuleValidator');
-const DependencyValidator = require('./marketplaceValidators/theme/DependencyValidator');
+const ThemeModuleValidator = require('./marketplaceValidators/theme/ThemeModuleValidator');
+const ThemeDependencyValidator = require('./marketplaceValidators/theme/ThemeDependencyValidator');
+
+const ModuleValidator = require('./marketplaceValidators/module/ModuleValidator');
+const ModuleDependencyValidator = require('./marketplaceValidators/module/ModuleDependencyValidator');
 
 const MARKETPLACE_VALIDATORS = {
   theme: [
     ThemeConfigValidator,
     SectionValidator,
     TemplateValidator,
-    ModuleValidator,
-    DependencyValidator,
+    ThemeModuleValidator,
+    ThemeDependencyValidator,
   ],
+  module: [ModuleValidator, ModuleDependencyValidator],
 };
 
 module.exports = MARKETPLACE_VALIDATORS;

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

@@ -2,23 +2,23 @@ const path = require('path');
 
 const { VALIDATION_RESULT } = require('../constants');
 
-class BaseValidator {
+class AbsoluteValidator {
   constructor({ name, key }) {
     this.name = name;
     this.key = key;
   }
 
-  clearThemePath() {
-    this._absoluteThemePath = null;
+  clearAbsolutePath() {
+    this._absolutePath = null;
   }
 
-  setThemePath(path) {
-    this._absoluteThemePath = path;
+  setAbsolutePath(path) {
+    this._absolutePath = path;
   }
 
   getRelativePath(filePath) {
-    return this._absoluteThemePath
-      ? path.relative(this._absoluteThemePath, filePath)
+    return this._absolutePath
+      ? path.relative(this._absolutePath, filePath)
       : filePath;
   }
 
@@ -47,4 +47,4 @@ class BaseValidator {
   }
 }
 
-module.exports = BaseValidator;
+module.exports = AbsoluteValidator;

package/lib/validators/marketplaceValidators/RelativeValidator.js

@@ -0,0 +1,46 @@
+const { VALIDATION_RESULT } = require('../constants');
+
+class RelativeValidator {
+  constructor({ name, key }) {
+    this.name = name;
+    this.key = key;
+  }
+
+  clearRelativePath() {
+    this._relativePath = null;
+  }
+
+  setRelativePath(path) {
+    this._relativePath = path;
+  }
+
+  getRelativePath() {
+    return this._relativePath;
+  }
+
+  getSuccess() {
+    return {
+      validatorKey: this.key,
+      validatorName: this.name,
+      result: VALIDATION_RESULT.SUCCESS,
+    };
+  }
+
+  getError(errorObj, file, extraContext = {}) {
+    const relativeFilePath = this.getRelativePath();
+    const context = {
+      filePath: relativeFilePath,
+      ...extraContext,
+    };
+    return {
+      validatorKey: this.key,
+      validatorName: this.name,
+      error: errorObj.getCopy(context),
+      result: errorObj.severity || VALIDATION_RESULT.FATAL,
+      key: `${this.key}.${errorObj.key}`,
+      context,
+    };
+  }
+}
+
+module.exports = RelativeValidator;

package/lib/validators/marketplaceValidators/module/ModuleDependencyValidator.js

@@ -0,0 +1,101 @@
+const path = require('path');
+
+const { logger } = require('@hubspot/cli-lib/logger');
+const { HUBSPOT_FOLDER } = require('@hubspot/cli-lib/lib/constants');
+const { fetchModuleDependencies } = require('@hubspot/cli-lib/api/marketplace');
+const { isRelativePath } = require('@hubspot/cli-lib/path');
+
+const RelativeValidator = require('../RelativeValidator');
+const { VALIDATOR_KEYS } = require('../../constants');
+
+class ModuleDependencyValidator extends RelativeValidator {
+  constructor(options) {
+    super(options);
+
+    this.errors = {
+      FAILED_TO_FETCH_DEPS: {
+        key: 'failedDepFetch',
+        getCopy: ({ filePath }) =>
+          `Internal Error. Failed to fetch dependencies for ${filePath}. Please try again`,
+      },
+      EXTERNAL_DEPENDENCY: {
+        key: 'externalDependency',
+        getCopy: ({ filePath, referencedFilePath }) =>
+          `External dependency. ${filePath} references a file (${referencedFilePath}) that is outside of the module's immediate folder.`,
+      },
+      ABSOLUTE_DEPENDENCY_PATH: {
+        key: 'absoluteDependencyPath',
+        getCopy: ({ filePath, referencedFilePath }) =>
+          `Relative path required. ${filePath} references a file (${referencedFilePath}) using an absolute path`,
+      },
+    };
+  }
+
+  failedToFetchDependencies(err, relativePath, validationErrors) {
+    logger.debug(
+      `Failed to fetch dependencies for ${relativePath}: `,
+      err.error
+    );
+
+    validationErrors.push(
+      this.getError(this.errors.FAILED_TO_FETCH_DEPS, relativePath)
+    );
+  }
+
+  async getAllDependenciesByPath(relativePath, accountId, validationErrors) {
+    let deps = [];
+    const file_deps = await fetchModuleDependencies(
+      accountId,
+      relativePath
+    ).catch(err => {
+      this.failedToFetchDependencies(err, relativePath, validationErrors);
+      return null;
+    });
+    if (file_deps) {
+      deps = file_deps.dependencies || [];
+    }
+    return deps;
+  }
+
+  isExternalDep(relPath, relativeDepPath) {
+    const moduleDir = path.parse(relPath).dir;
+    const depDir = path.parse(relativeDepPath).dir;
+    return !depDir.startsWith(moduleDir);
+  }
+
+  // Validates:
+  // - Module does not contain external dependencies
+  // - All paths are either @hubspot or relative
+  async validate(relativePath, accountId) {
+    let validationErrors = [];
+
+    const dependencyData = await this.getAllDependenciesByPath(
+      relativePath,
+      accountId,
+      validationErrors
+    );
+    dependencyData.forEach(dependency => {
+      if (!dependency.startsWith(HUBSPOT_FOLDER)) {
+        if (!isRelativePath(dependency)) {
+          validationErrors.push(
+            this.getError(this.errors.ABSOLUTE_DEPENDENCY_PATH, relativePath, {
+              referencedFilePath: dependency,
+            })
+          );
+        } else if (this.isExternalDep(relativePath, dependency)) {
+          validationErrors.push(
+            this.getError(this.errors.EXTERNAL_DEPENDENCY, relativePath, {
+              referencedFilePath: dependency,
+            })
+          );
+        }
+      }
+    });
+    return validationErrors;
+  }
+}
+
+module.exports = new ModuleDependencyValidator({
+  name: 'Module dependency',
+  key: VALIDATOR_KEYS.moduleDependency,
+});

package/lib/validators/marketplaceValidators/module/ModuleValidator.js

@@ -0,0 +1,102 @@
+const { logger } = require('@hubspot/cli-lib/logger');
+const { fetchModuleMeta } = require('@hubspot/cli-lib/api/marketplace');
+const RelativeValidator = require('../RelativeValidator');
+const { VALIDATOR_KEYS } = require('../../constants');
+
+class ModuleValidator extends RelativeValidator {
+  constructor(options) {
+    super(options);
+
+    this.errors = {
+      FAILED_TO_FETCH_META_JSON: {
+        key: 'failedMetaFetch',
+        getCopy: ({ filePath }) =>
+          `Internal error. Failed to fetch meta.json for ${filePath}. Please try again.`,
+      },
+      MISSING_META_JSON: {
+        key: 'missingMetaJSON',
+        getCopy: ({ filePath }) =>
+          `Module ${filePath} is missing the meta.json file`,
+      },
+      INVALID_META_JSON: {
+        key: 'invalidMetaJSON',
+        getCopy: ({ filePath }) =>
+          `Module ${filePath} has invalid json in the meta.json file`,
+      },
+      MISSING_LABEL: {
+        key: 'missingLabel',
+        getCopy: ({ filePath }) =>
+          `Missing required property for ${filePath}. The meta.json file is missing the "label" property`,
+      },
+      MISSING_ICON: {
+        key: 'missingIcon',
+        getCopy: ({ filePath }) =>
+          `Missing required property for ${filePath}. The meta.json file is missing the "icon" property`,
+      },
+    };
+  }
+  failedToFetchDependencies(err, relativePath, validationErrors) {
+    logger.debug(
+      `Failed to fetch dependencies for ${relativePath}: `,
+      err.error
+    );
+    validationErrors.push(
+      this.getError(this.errors.FAILED_TO_FETCH_META_JSON, relativePath)
+    );
+  }
+
+  async getModuleMetaByPath(relativePath, accountId, validationErrors) {
+    const moduleMeta = await fetchModuleMeta(accountId, relativePath).catch(
+      err => {
+        this.failedToFetchDependencies(err, relativePath, validationErrors);
+        return null;
+      }
+    );
+    return moduleMeta;
+  }
+
+  // Validates:
+  // - Module folder contains a meta.json file
+  // - Module meta.json file contains valid json
+  // - Module meta.json file has a "label" field
+  // - Module meta.json file has an "icon" field
+  async validate(relativePath, accountId) {
+    let validationErrors = [];
+    const metaJSONFile = await this.getModuleMetaByPath(
+      relativePath,
+      accountId,
+      validationErrors
+    );
+    if (!metaJSONFile) {
+      validationErrors.push(
+        this.getError(this.errors.MISSING_META_JSON, relativePath)
+      );
+    }
+    let metaJSON;
+    try {
+      metaJSON = JSON.parse(metaJSONFile.source);
+    } catch (err) {
+      validationErrors.push(
+        this.getError(this.errors.INVALID_META_JSON, relativePath)
+      );
+    }
+    if (metaJSON) {
+      if (!metaJSON.label) {
+        validationErrors.push(
+          this.getError(this.errors.MISSING_LABEL, relativePath)
+        );
+      }
+      if (!metaJSON.icon) {
+        validationErrors.push(
+          this.getError(this.errors.MISSING_ICON, relativePath)
+        );
+      }
+    }
+    return validationErrors;
+  }
+}
+
+module.exports = new ModuleValidator({
+  name: 'Module',
+  key: VALIDATOR_KEYS.module,
+});

package/lib/validators/marketplaceValidators/theme/SectionValidator.js

@@ -2,12 +2,12 @@ const {
   ANNOTATION_KEYS,
   buildAnnotationValueGetter,
 } = require('@hubspot/cli-lib/templates');
-const BaseValidator = require('../BaseValidator');
+const AbsoluteValidator = require('../AbsoluteValidator');
 const { VALIDATOR_KEYS } = require('../../constants');
 
 const SECTION_LIMIT = 50;
 
-class SectionValidator extends BaseValidator {
+class SectionValidator extends AbsoluteValidator {
   constructor(options) {
     super(options);
 

package/lib/validators/marketplaceValidators/theme/TemplateValidator.js

@@ -3,7 +3,7 @@ const {
   buildAnnotationValueGetter,
   isCodedFile,
 } = require('@hubspot/cli-lib/templates');
-const BaseValidator = require('../BaseValidator');
+const AbsoluteValidator = require('../AbsoluteValidator');
 const { VALIDATOR_KEYS } = require('../../constants');
 
 const TEMPLATE_LIMIT = 50;
@@ -50,7 +50,7 @@ const VALIDATIONS_BY_TYPE = {
   blog_post: { allowed: true, label: true, screenshot: true },
 };
 
-class TemplateValidator extends BaseValidator {
+class TemplateValidator extends AbsoluteValidator {
   constructor(options) {
     super(options);
 

package/lib/validators/marketplaceValidators/theme/ThemeConfigValidator.js

@@ -2,10 +2,10 @@ const fs = require('fs');
 const path = require('path');
 
 const { isRelativePath } = require('@hubspot/cli-lib/path');
-const BaseValidator = require('../BaseValidator');
+const AbsoluteValidator = require('../AbsoluteValidator');
 const { VALIDATOR_KEYS } = require('../../constants');
 
-class ThemeValidator extends BaseValidator {
+class ThemeValidator extends AbsoluteValidator {
   constructor(options) {
     super(options);
 
@@ -84,7 +84,7 @@ class ThemeValidator extends BaseValidator {
           );
         } else {
           const absoluteScreenshotPath = path.resolve(
-            this._absoluteThemePath,
+            this._absolutePath,
             themeJSON.screenshot_path
           );
           if (!fs.existsSync(absoluteScreenshotPath)) {

package/lib/validators/marketplaceValidators/theme/{DependencyValidator.js → ThemeDependencyValidator.js}

@@ -6,13 +6,15 @@ const {
   HUBL_EXTENSIONS,
   HUBSPOT_FOLDER,
 } = require('@hubspot/cli-lib/lib/constants');
-const { fetchDependencies } = require('@hubspot/cli-lib/api/marketplace');
+const {
+  fetchTemplateDependencies,
+} = require('@hubspot/cli-lib/api/marketplace');
 const { getExt, isRelativePath } = require('@hubspot/cli-lib/path');
 
-const BaseValidator = require('../BaseValidator');
+const AbsoluteValidator = require('../AbsoluteValidator');
 const { VALIDATOR_KEYS } = require('../../constants');
 
-class DependencyValidator extends BaseValidator {
+class ThemeDependencyValidator extends AbsoluteValidator {
   constructor(options) {
     super(options);
 
@@ -53,12 +55,13 @@ class DependencyValidator extends BaseValidator {
           if (!(source && source.trim())) {
             return { file, deps };
           }
-          const file_deps = await fetchDependencies(accountId, source).catch(
-            err => {
-              this.failedToFetchDependencies(err, file, validationErrors);
-              return null;
-            }
-          );
+          const file_deps = await fetchTemplateDependencies(
+            accountId,
+            source
+          ).catch(err => {
+            this.failedToFetchDependencies(err, file, validationErrors);
+            return null;
+          });
           if (file_deps) {
             deps = file_deps.dependencies || [];
           }
@@ -117,7 +120,7 @@ class DependencyValidator extends BaseValidator {
   }
 }
 
-module.exports = new DependencyValidator({
-  name: 'Dependency',
-  key: VALIDATOR_KEYS.dependency,
+module.exports = new ThemeDependencyValidator({
+  name: 'Theme dependency',
+  key: VALIDATOR_KEYS.themeDependency,
 });

package/lib/validators/marketplaceValidators/theme/{ModuleValidator.js → ThemeModuleValidator.js}

@@ -2,12 +2,12 @@ const fs = require('fs');
 const path = require('path');
 
 const { isModuleFolderChild } = require('@hubspot/cli-lib/modules');
-const BaseValidator = require('../BaseValidator');
+const AbsoluteValidator = require('../AbsoluteValidator');
 const { VALIDATOR_KEYS } = require('../../constants');
 
 const MODULE_LIMIT = 50;
 
-class ModuleValidator extends BaseValidator {
+class ThemeModuleValidator extends AbsoluteValidator {
   constructor(options) {
     super(options);
 
@@ -111,7 +111,7 @@ class ModuleValidator extends BaseValidator {
   }
 }
 
-module.exports = new ModuleValidator({
-  name: 'Module',
-  key: VALIDATOR_KEYS.module,
+module.exports = new ThemeModuleValidator({
+  name: 'Theme modules',
+  key: VALIDATOR_KEYS.themeModule,
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hubspot/cli",
-  "version": "3.0.13-beta.1",
+  "version": "3.0.13-beta.2",
   "description": "CLI for working with HubSpot",
   "license": "Apache-2.0",
   "repository": {
@@ -8,8 +8,8 @@
     "url": "https://github.com/HubSpot/hubspot-cms-tools"
   },
   "dependencies": {
-    "@hubspot/cli-lib": "3.0.13-beta.1",
-    "@hubspot/serverless-dev-runtime": "3.0.13-beta.1",
+    "@hubspot/cli-lib": "3.0.13-beta.2",
+    "@hubspot/serverless-dev-runtime": "3.0.13-beta.2",
     "archiver": "^5.3.0",
     "chalk": "^4.1.2",
     "express": "^4.17.1",
@@ -38,5 +38,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "1c84f581aac363971c008254b153613ace1241d9"
+  "gitHead": "ff694f8c61c2326159f7ad4d3f2cfdb18f8c1875"
 }