@hubspot/cli 3.0.12 → 3.0.13-beta.2

package/lib/serverlessLogs.js

@@ -1,5 +1,5 @@
 const https = require('https');
-
+const Spinnies = require('spinnies');
 const { logger } = require('@hubspot/cli-lib/logger');
 const { outputLogs } = require('@hubspot/cli-lib/lib/logs');
 const {
@@ -8,18 +8,32 @@ 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');
+    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 +58,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 +75,19 @@ 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}. Press "Q" to stop following`,
   });
 
+  handleUserInput(spinnies);
+
   await tail(initialAfter);
 };
 

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;