eslint-plugin-boundaries 2.4.2 → 2.7.0

package/README.md

@@ -1,6 +1,6 @@
 [![Build status][build-image]][build-url] [![Coverage Status][coveralls-image]][coveralls-url] [![Quality Gate][quality-gate-image]][quality-gate-url]
 
-[![NPM dependencies][npm-dependencies-image]][npm-dependencies-url] [![Renovate](https://img.shields.io/badge/renovate-enabled-brightgreen.svg)](https://renovatebot.com) [![Last commit][last-commit-image]][last-commit-url] [![Last release][release-image]][release-url]
+[![Renovate](https://img.shields.io/badge/renovate-enabled-brightgreen.svg)](https://renovatebot.com) [![Last commit][last-commit-image]][last-commit-url] [![Last release][release-image]][release-url]
 
 [![NPM downloads][npm-downloads-image]][npm-downloads-url] [![License][license-image]][license-url]
 
@@ -29,6 +29,7 @@ __This plugin ensures that your architecture boundaries are respected by the ele
   * [Rules configuration](#rules-configuration)
     * [Main format of rules options](#main-format-of-rules-options)
     * [Elements matchers](#elements-matchers)
+    * [Error messages](#error-messages)
     * [Advanced example](#advanced-example)
 - [Resolvers](#resolvers)
 - [Usage with TypeScript](#usage-with-typescript)
@@ -199,7 +200,7 @@ Define patterns to recognize each file in the project as one of this element typ
 }
 ```
 
-> Tip: You can enable the [debug mode](debug-mode) when configuring the plugin, and you will get information about the type assigned to each file in the project.
+> Tip: You can enable the [debug mode](#debug-mode) when configuring the plugin, and you will get information about the type assigned to each file in the project, as well as captured properties and values.
 
 #### __`boundaries/include`__
 
@@ -258,23 +259,31 @@ Some rules require extra configuration, and it has to be defined in each specifi
 
 #### Main format of rules options
 
-The docs of each rule contains an specification of their own options, but the main rules share the format in which the options have to be defined. The format described here is valid for options of [`element-types`](docs/rules/element-types.md), [`external`](docs/rules/external.md) and [`entry-point`](docs/rules/entry-point.md) rules.
+The docs of each rule contains an specification of their own options, but __the main rules share the format in which the options have to be defined__. The format described here is valid for options of [`element-types`](docs/rules/element-types.md), [`external`](docs/rules/external.md) and [`entry-point`](docs/rules/entry-point.md) rules, __except the `message` property, which for the moment is only supported in the [`element-types`](docs/rules/element-types.md) and [`entry-point`](docs/rules/entry-point.md) rules settings.
 
 Options set an "allow/disallow" value by default, and provide an array of rules. Each matching rule will override the default value and the value returned by previous matching rules. So, the final result of the options, once processed for each case, will be "allow" or "disallow", and this value will be applied by the plugin rule in the correspondant way, making it to produce an eslint error or not.
 
-```json
+```jsonc
 {
   "rules": {
     "boundaries/element-types": [2, {
+      // Allow or disallow any dependency by default
       "default": "allow",
+      // Define a custom message for this rule
+      "message": "${file.type} is not allowed to import ${dependency.type}",
       "rules": [
         {
+          // In this type of files...
           "from": ["helpers"],
-          "disallow": ["modules", "components", "helpers"]
+          // ...disallow importing this type of elements
+          "disallow": ["modules", "components"],
+          // ...and return this custom error message
+          "message": "Helpers must not import other thing than helpers"
         },
         {
           "from": ["components"],
           "disallow": ["modules"]
+          // As this rule has not "message" property, it will use the message defined at first level
         }
       ]
     }]
@@ -291,8 +300,9 @@ Remember that:
 
 * __`from/target`__: `<element matchers>` Depending of the rule to which the options are for, the rule will be applied only if the file being analized matches with this element matcher (`from`), or the dependency being imported matches with this element matcher (`target`).
 * __`disallow/allow`__: `<value matchers>` If the plugin rule target matches with this, then the result of the rule will be "disallow/allow". Each rule will require a type of value here depending of what it is checking. In the case of the `element-types` rule, for example, another `<element matcher>` has to be provided in order to check the type of the local dependency.
+* __`message`__: `<string>` Optional. If the rule results in an error, the plugin will return this message instead of the default one. Read [error messages](#error-messages) for further info.
 
-> Tip: All properties can receive a single matcher, or an array of matchers.
+> Tip: Properties `from/target` and `disallow/allow` can receive a single matcher, or an array of matchers.
 
 ##### Elements matchers
 
@@ -303,6 +313,29 @@ Elements matchers used in the rules options can have the next formats:
   * `["helpers", { category: "data", elementName: "parsers"}]`: Will only match with helpers with category "data" and elementName "parsers" (`helpers/data/parsers.js`).
   * `["helpers", { category: "data" }]`: Will match with all helpers with category "data" (`helpers/data/*.js`)
 
+##### Error messages
+
+The plugin returns a different default message for each rule, check the documentation of each one for further info. But some rules support defining custom messages in their configuration, as seen in ["Main format of rules options"](#main-format-of-rules-options).
+
+When defining custom messages, it is possible to provide information about the current file or dependency. Use `${file.PROPERTY}` or `${dependency.PROPERTY}`, and it will be replaced by the correspondent captured value from the file or the dependency:
+
+```jsonc
+{
+  "message": "${file.type}s of category ${file.category} are not allowed to import ${dependency.category}s"
+  // If the error was produced by a file with type "component" and captured value "category" being "atom", trying to import a dependency with category "molecule", the message would be:
+  // "components of category atom are not allowed to import molecules"
+}
+```
+
+Available properties in error templates both from `file` or `dependency` are:
+
+* `type`: Element's type.
+* `internalPath`: File path being analyzed or imported. Relative to the element's root path.
+* ...All captured properties are also available
+
+
+> Tip: Read ["Global settings"](#global-settings) for further info about how to capture values from elements.
+
 ##### Advanced example of a rule configuration
 
 Just to illustrate the high level of customization that the plugin supports, here is an example of advanced options for the `boundaries/element-types` rule based on the previous global `elements` settings example:
@@ -343,7 +376,9 @@ Just to illustrate the high level of customization that the plugin supports, her
           "disallow": [
             // disallow importing helpers with captured category "data"
             ["helpers", { "category": "data" }]
-          ]
+          ],
+          // Custom message only for this specific error
+          "message": "Atom components can't import data helpers"
         },
         {
           // when file is inside a module
@@ -360,7 +395,9 @@ Just to illustrate the high level of customization that the plugin supports, her
           "disallow": [
             // disallow importing any type of component not being of family layout
             ["components", { "family": "!layout" }]
-          ]
+          ],
+          // Custom message only for this specific error
+          "message": "Modules with name starting by 'page-' can't import not layout components. You tried to import a component of family ${dependency.family} from a module with name ${file.elementName}"
         }
       ]
     }]
@@ -456,8 +493,6 @@ MIT, see [LICENSE](./LICENSE) for details.
 [license-url]: https://github.com/javierbrea/eslint-plugin-boundaries/blob/master/LICENSE
 [npm-downloads-image]: https://img.shields.io/npm/dm/eslint-plugin-boundaries.svg
 [npm-downloads-url]: https://www.npmjs.com/package/eslint-plugin-boundaries
-[npm-dependencies-image]: https://img.shields.io/david/javierbrea/eslint-plugin-boundaries.svg
-[npm-dependencies-url]: https://david-dm.org/javierbrea/eslint-plugin-boundaries
 [quality-gate-image]: https://sonarcloud.io/api/project_badges/measure?project=javierbrea_eslint-plugin-boundaries&metric=alert_status
 [quality-gate-url]: https://sonarcloud.io/dashboard?id=javierbrea_eslint-plugin-boundaries
 [release-image]: https://img.shields.io/github/release-date/javierbrea/eslint-plugin-boundaries.svg

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-boundaries",
-  "version": "2.4.2",
+  "version": "2.7.0",
   "description": "Eslint plugin checking architecture boundaries between elements",
   "keywords": [
     "eslint",
@@ -28,25 +28,25 @@
     "prepare": "is-ci || husky install"
   },
   "peerDependencies": {
-    "eslint": "^6.0.0 || ^7.0.0"
+    "eslint": ">=6.0.0"
   },
   "dependencies": {
     "eslint-import-resolver-node": "0.3.6",
-    "eslint-module-utils": "2.6.2",
+    "eslint-module-utils": "2.7.1",
     "chalk": "4.1.2",
-    "is-core-module": "2.5.0",
+    "is-core-module": "2.8.0",
     "micromatch": "4.0.4"
   },
   "devDependencies": {
     "cross-env": "7.0.3",
-    "eslint": "7.32.0",
+    "eslint": "8.3.0",
     "eslint-config-prettier": "8.3.0",
-    "eslint-plugin-prettier": "3.4.0",
-    "husky": "7.0.1",
-    "is-ci": "3.0.0",
-    "jest": "27.0.6",
-    "lint-staged": "11.1.2",
-    "prettier": "2.3.2"
+    "eslint-plugin-prettier": "4.0.0",
+    "husky": "7.0.4",
+    "is-ci": "3.0.1",
+    "jest": "27.3.1",
+    "lint-staged": "12.1.2",
+    "prettier": "2.4.1"
   },
   "lint-staged": {
     "test/**/*.js": "eslint",
@@ -54,6 +54,6 @@
     "*.js": "eslint"
   },
   "engines": {
-    "node": "10.x || 12.x || 14.x || 15.x || 16.x"
+    "node": ">=12.0.0"
   }
 }

package/src/core/cache.js

@@ -1,5 +1,3 @@
-const { debug } = require("../helpers/debug");
-
 class Cache {
   constructor(name, settings) {
     this._cache = {};
@@ -13,7 +11,6 @@ class Cache {
 
   load(key) {
     if (this._cache[key]) {
-      debug(`Returning "${key}" ${this._name} info from cache`);
       return this._cache[key];
     }
 
@@ -32,7 +29,6 @@ class CachesManager {
       return cacheCandidate._settings === settings;
     });
     if (!cache) {
-      debug(`${this._name} cache not found, creating new`);
       cache = new Cache(this._name, settings);
       this._caches.push(cache);
     }

package/src/core/elementsInfo.js

@@ -5,6 +5,7 @@ const resolve = require("eslint-module-utils/resolve").default;
 const { IGNORE, INCLUDE, VALID_MODES } = require("../constants/settings");
 const { getElements } = require("../helpers/settings");
 const { debugFileInfo } = require("../helpers/debug");
+const { isArray } = require("../helpers/utils");
 
 const { filesCache, importsCache, elementsCache } = require("./cache");
 
@@ -112,9 +113,7 @@ function elementTypeAndParents(path, settings) {
         let elementFound = false;
         getElements(settings).forEach((element) => {
           const typeOfMatch = VALID_MODES.includes(element.mode) ? element.mode : VALID_MODES[0];
-          const elementPatterns = Array.isArray(element.pattern)
-            ? element.pattern
-            : [element.pattern];
+          const elementPatterns = isArray(element.pattern) ? element.pattern : [element.pattern];
           elementPatterns.forEach((elementPattern) => {
             if (!elementFound) {
               const useFullPathMatch = typeOfMatch === VALID_MODES[2] && !elementResult.type;

package/src/helpers/messages.js

@@ -0,0 +1,117 @@
+const { isString, isArray, replaceObjectValuesInTemplates } = require("./utils");
+const { micromatchPatternReplacingObjectValues } = require("./rules");
+
+function quote(str) {
+  return `'${str}'`;
+}
+
+function typeMessage(elementMatcher) {
+  return `elements of type ${quote(elementMatcher)}`;
+}
+
+function propertiesConcater(properties, index) {
+  if (properties.length > 1 && index === properties.length - 1) {
+    return " and";
+  }
+  if (index === 0) {
+    return " with";
+  }
+  return ",";
+}
+
+function micromatchPatternMessage(micromatchPatterns, elementCapturedValues) {
+  const micromatchPatternsWithValues = micromatchPatternReplacingObjectValues(
+    micromatchPatterns,
+    elementCapturedValues
+  );
+  if (isArray(micromatchPatternsWithValues)) {
+    if (micromatchPatternsWithValues.length === 1) {
+      return quote(micromatchPatternsWithValues[0]);
+    }
+    return micromatchPatternsWithValues.reduce((message, micromatchPattern, index) => {
+      if (index === 0) {
+        return quote(micromatchPattern);
+      }
+      if (index === micromatchPatternsWithValues.length - 1) {
+        return `${message} or ${quote(micromatchPattern)}`;
+      }
+      return `${message}, ${quote(micromatchPattern)}`;
+    }, "");
+  }
+  return quote(micromatchPatternsWithValues);
+}
+
+function capturedValuesMatcherMessage(capturedValuesPattern, elementCapturedValues) {
+  const capturedValuesPatternKeys = Object.keys(capturedValuesPattern);
+  return capturedValuesPatternKeys
+    .map((key) => {
+      return [key, capturedValuesPattern[key]];
+    })
+    .reduce((message, propertyNameAndMatcher, index) => {
+      return `${message}${propertiesConcater(capturedValuesPatternKeys, index)} ${
+        propertyNameAndMatcher[0]
+      } ${micromatchPatternMessage(propertyNameAndMatcher[1], elementCapturedValues)}`;
+    }, "");
+}
+
+function elementMatcherMessage(elementMatcher, elementCapturedValues) {
+  if (isString(elementMatcher)) {
+    return typeMessage(elementMatcher);
+  }
+  return `${typeMessage(elementMatcher[0])}${capturedValuesMatcherMessage(
+    elementMatcher[1],
+    elementCapturedValues
+  )}`;
+}
+
+function ruleElementMessage(elementPatterns, elementCapturedValues) {
+  if (isArray(elementPatterns)) {
+    if (elementPatterns.length === 1) {
+      return elementMatcherMessage(elementPatterns[0], elementCapturedValues);
+    }
+    return elementPatterns.reduce((message, elementPattern, index) => {
+      if (index === 0) {
+        return elementMatcherMessage(elementPattern, elementCapturedValues);
+      }
+      return `${message}, or ${elementMatcherMessage(elementPattern, elementCapturedValues)}`;
+    }, "");
+  }
+  return elementMatcherMessage(elementPatterns, elementCapturedValues);
+}
+
+function customErrorMessage(message, file, dependency) {
+  return replaceObjectValuesInTemplates(
+    replaceObjectValuesInTemplates(message, { ...file.capturedValues, type: file.type }, "file"),
+    { ...dependency.capturedValues, type: dependency.type, internalPath: dependency.internalPath },
+    "dependency"
+  );
+}
+
+function elementCapturedValuesMessage(capturedValues) {
+  if (!capturedValues) {
+    return "";
+  }
+  const capturedValuesKeys = Object.keys(capturedValues);
+  return capturedValuesKeys
+    .map((key) => {
+      return [key, capturedValues[key]];
+    })
+    .reduce((message, propertyNameAndValue, index) => {
+      return `${message}${propertiesConcater(capturedValuesKeys, index)} ${
+        propertyNameAndValue[0]
+      } ${quote(propertyNameAndValue[1])}`;
+    }, "");
+}
+
+function elementMessage(elementInfo) {
+  return `of type ${quote(elementInfo.type)}${elementCapturedValuesMessage(
+    elementInfo.capturedValues
+  )}`;
+}
+
+module.exports = {
+  quote,
+  ruleElementMessage,
+  customErrorMessage,
+  elementMessage,
+};

package/src/helpers/rules.js

@@ -1,9 +1,15 @@
 const micromatch = require("micromatch");
 
+const { isArray, replaceObjectValuesInTemplates } = require("./utils");
+
 const REPO_URL = "https://github.com/javierbrea/eslint-plugin-boundaries";
 
+function removePluginNamespace(ruleName) {
+  return ruleName.replace("boundaries/", "");
+}
+
 function docsUrl(ruleName) {
-  return `${REPO_URL}/blob/master/docs/rules/${ruleName}.md`;
+  return `${REPO_URL}/blob/master/docs/rules/${removePluginNamespace(ruleName)}.md`;
 }
 
 function meta({ description, schema = [], ruleName }) {
@@ -39,9 +45,7 @@ function dependencyLocation(node, context) {
 }
 
 function micromatchPatternReplacingObjectValues(pattern, object) {
-  return Object.keys(object).reduce((result, objectKey) => {
-    return result.replace(`\${${objectKey}}`, object[objectKey]);
-  }, pattern);
+  return replaceObjectValuesInTemplates(pattern, object);
 }
 
 function isObjectMatch(objectWithMatchers, object, objectWithValuesToReplace) {
@@ -65,10 +69,10 @@ function rulesMainKey(key) {
 
 function ruleMatch(ruleMatchers, elementInfo, isMatch, elementToCompare = {}) {
   let match = { result: false, report: null };
-  const matchers = !Array.isArray(ruleMatchers) ? [ruleMatchers] : ruleMatchers;
+  const matchers = !isArray(ruleMatchers) ? [ruleMatchers] : ruleMatchers;
   matchers.forEach((matcher) => {
     if (!match.result) {
-      if (Array.isArray(matcher)) {
+      if (isArray(matcher)) {
         const [value, captures] = matcher;
         match = isMatch(elementInfo, value, captures, elementToCompare.capturedValues);
       } else {
@@ -106,9 +110,16 @@ function getElementRules(elementInfo, options, mainKey) {
     return [];
   }
   const key = rulesMainKey(mainKey);
-  return options.rules.filter((rule) => {
-    return ruleMatch(rule[key], elementInfo, isMatchElementType).result;
-  });
+  return options.rules
+    .map((rule, index) => {
+      return {
+        ...rule,
+        index,
+      };
+    })
+    .filter((rule) => {
+      return ruleMatch(rule[key], elementInfo, isMatchElementType).result;
+    });
 }
 
 function elementRulesAllowDependency({
@@ -118,12 +129,21 @@ function elementRulesAllowDependency({
   isMatch,
   rulesMainKey: mainKey,
 }) {
-  const [result, report] = getElementRules(element, options, mainKey).reduce(
+  const [result, report, ruleReport] = getElementRules(element, options, mainKey).reduce(
     (allowed, rule) => {
       if (rule.disallow) {
         const match = ruleMatch(rule.disallow, dependency, isMatch, element);
         if (match.result) {
-          return [false, match.report];
+          return [
+            false,
+            match.report,
+            {
+              element: rule[rulesMainKey(mainKey)],
+              disallow: rule.disallow,
+              index: rule.index,
+              message: rule.message || options.message,
+            },
+          ];
         }
       }
       if (rule.allow) {
@@ -134,11 +154,19 @@ function elementRulesAllowDependency({
       }
       return allowed;
     },
-    [options.default === "allow", null]
+    [
+      options.default === "allow",
+      null,
+      {
+        isDefault: true,
+        message: options.message,
+      },
+    ]
   );
   return {
     result,
     report,
+    ruleReport,
   };
 }
 
@@ -151,4 +179,5 @@ module.exports = {
   elementRulesAllowDependency,
   getElementRules,
   rulesMainKey,
+  micromatchPatternReplacingObjectValues,
 };

package/src/helpers/settings.js

@@ -1,7 +1,8 @@
 const { TYPES, ELEMENTS, VALID_MODES } = require("../constants/settings");
+const { isString } = require("./utils");
 
 function isLegacyType(type) {
-  return typeof type === "string";
+  return isString(type);
 }
 
 // TODO, remove in next major version

package/src/helpers/utils.js

@@ -0,0 +1,30 @@
+function isString(object) {
+  return typeof object === "string";
+}
+
+function isArray(object) {
+  return Array.isArray(object);
+}
+
+function replaceObjectValueInTemplate(template, key, value, namespace) {
+  const keyToReplace = namespace ? `${namespace}.${key}` : key;
+  return template.replace(`\${${keyToReplace}}`, value);
+}
+
+function replaceObjectValuesInTemplates(strings, object, namespace) {
+  return Object.keys(object).reduce((result, objectKey) => {
+    // If template is an array, replace key by value in all patterns
+    if (isArray(result)) {
+      return result.map((resultEntry) => {
+        return replaceObjectValueInTemplate(resultEntry, objectKey, object[objectKey], namespace);
+      });
+    }
+    return replaceObjectValueInTemplate(result, objectKey, object[objectKey], namespace);
+  }, strings);
+}
+
+module.exports = {
+  isString,
+  isArray,
+  replaceObjectValuesInTemplates,
+};

package/src/helpers/validations.js

@@ -5,6 +5,7 @@ const { TYPES, ALIAS, ELEMENTS, VALID_MODES } = require("../constants/settings")
 const { getElementsTypeNames, isLegacyType } = require("./settings");
 const { rulesMainKey } = require("./rules");
 const { warnOnce } = require("./debug");
+const { isArray, isString } = require("./utils");
 
 const invalidMatchers = [];
 
@@ -41,9 +42,9 @@ function elementsMatcherSchema(matcherOptions = DEFAULT_MATCHER_OPTIONS) {
   };
 }
 
-function rulesOptionsSchema(options = {}) {
+function rulesOptionsSchema(options) {
   const mainKey = rulesMainKey(options.rulesMainKey);
-  return [
+  const schema = [
     {
       type: "object",
       properties: {
@@ -78,15 +79,26 @@ function rulesOptionsSchema(options = {}) {
       additionalProperties: false,
     },
   ];
+  if (options.customMessage) {
+    schema[0].properties.message = {
+      type: "string",
+    };
+  }
+  if (options.customRuleMessage) {
+    schema[0].properties.rules.items.properties.message = {
+      type: "string",
+    };
+  }
+  return schema;
 }
 
 function isValidElementTypesMatcher(matcher, settings) {
-  const mathcherToCheck = Array.isArray(matcher) ? matcher[0] : matcher;
+  const mathcherToCheck = isArray(matcher) ? matcher[0] : matcher;
   return !matcher || micromatch.some(getElementsTypeNames(settings), mathcherToCheck);
 }
 
 function validateElementTypesMatcher(elementsMatcher, settings) {
-  const [matcher] = Array.isArray(elementsMatcher) ? elementsMatcher : [elementsMatcher];
+  const [matcher] = isArray(elementsMatcher) ? elementsMatcher : [elementsMatcher];
   if (!invalidMatchers.includes(matcher) && !isValidElementTypesMatcher(matcher, settings)) {
     invalidMatchers.push(matcher);
     warnOnce(`Option '${matcher}' does not match any element type from '${ELEMENTS}' setting`);
@@ -94,7 +106,7 @@ function validateElementTypesMatcher(elementsMatcher, settings) {
 }
 
 function validateElements(elements) {
-  if (!elements || !Array.isArray(elements) || !elements.length) {
+  if (!elements || !isArray(elements) || !elements.length) {
     warnOnce(`Please provide element types using the '${ELEMENTS}' setting`);
     return;
   }
@@ -106,7 +118,7 @@ function validateElements(elements) {
       );
     } else {
       Object.keys(element).forEach(() => {
-        if (!element.type || typeof element.type !== "string") {
+        if (!element.type || !isString(element.type)) {
           warnOnce(`Please provide type in '${ELEMENTS}' setting`);
         }
         if (element.mode && !VALID_MODES.includes(element.mode)) {
@@ -116,13 +128,10 @@ function validateElements(elements) {
             )}. Default value "${VALID_MODES[0]}" will be used instead`
           );
         }
-        if (
-          !element.pattern ||
-          !(typeof element.pattern === "string" || Array.isArray(element.pattern))
-        ) {
+        if (!element.pattern || !(isString(element.pattern) || isArray(element.pattern))) {
           warnOnce(`Please provide a valid pattern in '${ELEMENTS}' setting`);
         }
-        if (element.capture && !Array.isArray(element.capture)) {
+        if (element.capture && !isArray(element.capture)) {
           warnOnce(`Invalid capture property in '${ELEMENTS}' setting`);
         }
       });

package/src/rules/element-types.js

@@ -8,6 +8,7 @@ const {
   isMatchElementType,
   elementRulesAllowDependency,
 } = require("../helpers/rules");
+const { customErrorMessage, ruleElementMessage, elementMessage } = require("../helpers/messages");
 
 function elementRulesAllowDependencyType(element, dependency, options) {
   return elementRulesAllowDependency({
@@ -15,28 +16,47 @@ function elementRulesAllowDependencyType(element, dependency, options) {
     dependency,
     options,
     isMatch: isMatchElementType,
-  }).result;
+  });
+}
+
+function errorMessage(ruleData, file, dependency) {
+  const ruleReport = ruleData.ruleReport;
+  if (ruleReport.message) {
+    return customErrorMessage(ruleReport.message, file, dependency);
+  }
+  if (ruleReport.isDefault) {
+    return `No rule allowing this dependency was found. File is ${elementMessage(
+      file
+    )}. Dependency is ${elementMessage(dependency)}`;
+  }
+  return `Importing ${ruleElementMessage(
+    ruleReport.disallow,
+    file.capturedValues
+  )} is not allowed in ${ruleElementMessage(
+    ruleReport.element,
+    file.capturedValues
+  )}. Disallowed in rule ${ruleReport.index + 1}`;
 }
 
 module.exports = dependencyRule(
   {
     ruleName: RULE_ELEMENT_TYPES,
     description: `Check allowed dependencies between element types`,
-    schema: rulesOptionsSchema(),
+    schema: rulesOptionsSchema({
+      customMessage: true,
+      customRuleMessage: true,
+    }),
   },
   function ({ dependency, file, node, context, options }) {
-    if (
-      dependency.isLocal &&
-      !dependency.isIgnored &&
-      dependency.type &&
-      !dependency.isInternal &&
-      !elementRulesAllowDependencyType(file, dependency, options)
-    ) {
-      context.report({
-        message: `Usage of '${dependency.type}' is not allowed in '${file.type}'`,
-        node: node,
-        ...dependencyLocation(node, context),
-      });
+    if (dependency.isLocal && !dependency.isIgnored && dependency.type && !dependency.isInternal) {
+      const ruleData = elementRulesAllowDependencyType(file, dependency, options);
+      if (!ruleData.result) {
+        context.report({
+          message: errorMessage(ruleData, file, dependency),
+          node: node,
+          ...dependencyLocation(node, context),
+        });
+      }
     }
   }
 );

package/src/rules/entry-point.js

@@ -8,6 +8,7 @@ const {
   isMatchElementKey,
   elementRulesAllowDependency,
 } = require("../helpers/rules");
+const { customErrorMessage, ruleElementMessage, elementMessage } = require("../helpers/messages");
 
 function isMatchElementInternalPath(elementInfo, matcher, options) {
   return isMatchElementKey(elementInfo, matcher, options, "internalPath");
@@ -20,7 +21,23 @@ function elementRulesAllowEntryPoint(element, dependency, options) {
     options,
     isMatch: isMatchElementInternalPath,
     rulesMainKey: "target",
-  }).result;
+  });
+}
+
+function errorMessage(ruleData, file, dependency) {
+  const ruleReport = ruleData.ruleReport;
+  if (ruleReport.message) {
+    return customErrorMessage(ruleReport.message, file, dependency);
+  }
+  if (ruleReport.isDefault) {
+    return `No rule allows the entry point '${
+      dependency.internalPath
+    }' in dependencies ${elementMessage(dependency)}`;
+  }
+  return `The entry point '${dependency.internalPath}' is not allowed in ${ruleElementMessage(
+    ruleReport.element,
+    dependency.capturedValues
+  )}. Disallowed in rule ${ruleReport.index + 1}`;
 }
 
 module.exports = dependencyRule(
@@ -29,20 +46,20 @@ module.exports = dependencyRule(
     description: `Check entry point used for each element type`,
     schema: rulesOptionsSchema({
       rulesMainKey: "target",
+      customMessage: true,
+      customRuleMessage: true,
     }),
   },
   function ({ dependency, file, node, context, options }) {
-    if (
-      !dependency.isIgnored &&
-      dependency.type &&
-      !dependency.isInternal &&
-      !elementRulesAllowEntryPoint(file, dependency, options)
-    ) {
-      context.report({
-        message: `Entry point '${dependency.internalPath}' is not allowed in '${dependency.type}'`,
-        node: node,
-        ...dependencyLocation(node, context),
-      });
+    if (!dependency.isIgnored && dependency.type && !dependency.isInternal) {
+      const ruleData = elementRulesAllowEntryPoint(file, dependency, options);
+      if (!ruleData.result) {
+        context.report({
+          message: errorMessage(ruleData, file, dependency),
+          node: node,
+          ...dependencyLocation(node, context),
+        });
+      }
     }
   },
   {

package/src/rules/no-private.js

@@ -1,4 +1,4 @@
-const { RULE_NO_INTERNAL } = require("../constants/settings");
+const { RULE_NO_PRIVATE } = require("../constants/settings");
 
 const dependencyRule = require("../rules-factories/dependency-rule");
 
@@ -6,7 +6,7 @@ const { dependencyLocation } = require("../helpers/rules");
 
 module.exports = dependencyRule(
   {
-    ruleName: RULE_NO_INTERNAL,
+    ruleName: RULE_NO_PRIVATE,
     description: `Prevent importing private elements of another element`,
     schema: [
       {

package/src/rules-factories/dependency-rule.js

@@ -5,9 +5,9 @@ const { validateSettings, validateRules } = require("../helpers/validations");
 
 const { meta } = require("../helpers/rules");
 
-module.exports = function (ruleDescription, rule, ruleOptions = {}) {
+module.exports = function (ruleMeta, rule, ruleOptions = {}) {
   return {
-    ...meta(ruleDescription),
+    ...meta(ruleMeta),
     create: function (context) {
       const options = context.options[0];
       validateSettings(context.settings);

package/CHANGELOG.md

@@ -1,208 +0,0 @@
-# Change Log
-All notable changes to this project will be documented in this file.
-
-The format is based on [Keep a Changelog](http://keepachangelog.com/)
-and this project adheres to [Semantic Versioning](http://semver.org/).
-
-## [unreleased]
-### Added
-### Changed
-### Fixed
-### Removed
-### BREAKING CHANGES
-
-## [2.4.2] - 2021-08-22
-
-### Added
-- docs(#107): Add usage with TypeScript docs
-
-### Changed
-- chore(deps): Update devDependencies
-
-
-## [2.4.1] - 2021-08-16
-
-### Fixed
-- fix: Remove trace when ESLINT_PLUGIN_BOUNDARIES_DEBUG is not set
-
-## [2.4.0] - 2021-08-15
-
-### Added
-- feat: Improve performance adding internal cache
-
-### Changed
-- chore(deps): Update devDependencies
-
-## [2.3.0] - 2021-07-20
-
-### Added
-- feat(#131): Add `boundaries/include` option allowing to ignore all by default except files matching the pattern.
-
-### Changed
-- feat(#132): Detect paths from any `node_modules` folder as external
-- chore(deps): Update devDependencies
-
-## [2.2.0] - 2021-05-29
-
-### Added
-- chore(deps): Add node.js v16.x to engines and add tests using it
-
-### Changed
-- chore(deps): Update devDependencies
-- chore: Migrate Sonar project
-## [2.1.0] - 2021-03-25
-
-### Added
-- feat: Add basePattern and baseCapture options to elements settings (#97)
-
-### Changed
-- chore(deps): Update dependencies
-
-### Fixed
-- fix: Avoid crash when import path is broken (#96)
-
-## [2.0.0] - 2021-02-02
-
-### Added
-- feat: Support multiple levels of categorization and any type of project structure (#75)
-- feat: Support elements as files (#75)
-- feat(settings): Added support for `import/resolver` setting
-- feat(options): Support micromatch patterns in rules options (#11, #10)
-- feat: Add debug mode
-- test: Add more than 500 tests using different project structure examples, with different categorization levels, elements as folders, as files, etc.
-- test: Add one test for each rules docs example
-- chore: Run tests on Windows OS again (#74)
-
-### Changed
-- feat(settings): Deprecated `boundaries/types` setting. `boundaries/elements` should be used instead. If it is not present, `boundaries/types` will be used as fallback
-- feat(rules): Rename `allowed-types` rule into `element-types` (now it can be used to allow/disallow). Change the format of rule options
-- feat(rules): Rename `no-external` rule into `external` (now it can be used to allow/disallow). Change the format of rule options
-- feat(rules): Change the format of `entry-point` rule options (now it support allow/disallow format)
-- feat(rules): Rename `no-import-ignored` rule into `no-ignored` (the majority of the plugin rules are referred to `import` statements, so it is not necessary to specify it in the rule name)
-- feat(rules): Rename `no-import-not-recognized-types` rule into `no-unknown`
-- feat(rules): Rename `prefer-recognized-types` rule into `no-unknown-files`
-- refactor(core): Use `eslint-module-utils/resolve` to get files and import paths. Use `micromatch` to match settings and options. Adapt the whole core to this new approach
-
-### Fixed
-- fix: Support scoped packages in external rule (#59)
-
-### Removed
-- feat(settings): Removed `boundaries/alias` setting
-
-### BREAKING CHANGES
-- Removed `boundaries/alias` setting. `import/resolver` has to be used instead
-- Renamed `allowed-types` rule into `element-types` (now it can be used to allow/disallow). Changed the format of rule options
-- Changed the format of `entry-point` rule options (now it support allow/disallow format)
-- Renamed `no-external` rule into `external` (now it can be used to allow/disallow). Changed the format of rule options
-- Renamed `no-import-ignored` rule into `no-ignored` (the majority of the plugin rules are referred to `import` statements, so it is not necessary to specify it in the rule name)
-- Renamed `no-import-not-recognized-types` rule into `no-unknown`
-- Renamed `prefer-recognized-types` rule into `no-unknown-files`
-
-## [2.0.0-beta.4] - 2021-01-30
-
-### Added
-- feat: debug files and imports info when ESLINT_PLUGIN_BOUNDARIES_DEBUG environment variable exists
-- feat: `mode` option in `elements` setting now also accepts `full` as value. Pattern will try to match the full path in that case.
-- feat: support defining multiple micromatch patterns in an array in the `pattern` property of `elements` setting.
-
-## [2.0.0-beta.3] - 2021-01-26
-
-### Fixed
-- fix: node_modules packages were being recognized as local
-
-## [2.0.0-beta.2] - 2021-01-26
-
-### Fixed
-- fix: Add folder resolver-legacy-alias to npm package
-
-## [2.0.0-beta.1] - 2021-01-26
-
-### Added
-- feat: Support multiple levels of categorization and any type of project structure (#75)
-- feat: Support elements as files (#75)
-- feat(settings): Added support for `import/resolver` setting
-- feat(options): Support micromatch patterns in rules options (#11, #10)
-- test: Add more than 500 tests using different project structure examples, with different categorization levels, elements as folders, as files, etc.
-- test: Add one test for each rules docs example
-
-### Changed
-- feat(settings): Deprecated `boundaries/types` setting. `boundaries/elements` should be used instead. If it is not present, `boundaries/types` will be used as fallback
-- feat(rules): Rename `allowed-types` rule into `element-types` (now it can be used to allow/disallow). Change the format of rule options
-- feat(rules): Rename `no-external` rule into `external` (now it can be used to allow/disallow). Change the format of rule options
-- feat(rules): Change the format of `entry-point` rule options (now it support allow/disallow format)
-- feat(rules): Rename `no-import-ignored` rule into `no-ignored` (the majority of the plugin rules are referred to `import` statements, so it is not necessary to specify it in the rule name)
-- feat(rules): Rename `no-import-not-recognized-types` rule into `no-unknown`
-- feat(rules): Rename `prefer-recognized-types` rule into `no-unknown-files`
-- refactor(core): Use `eslint-module-utils/resolve` to get files and import paths. Use `micromatch` to match settings and options. Adapt the whole core to this new approach
-
-### Fixed
-- fix: Support scoped packages in external rule (#59)
-
-### Removed
-- feat(settings): Removed `boundaries/alias` setting
-
-### BREAKING CHANGES
-- Removed `boundaries/alias` setting. `import/resolver` has to be used instead
-- Renamed `allowed-types` rule into `element-types` (now it can be used to allow/disallow). Changed the format of rule options
-- Changed the format of `entry-point` rule options (now it support allow/disallow format)
-- Renamed `no-external` rule into `external` (now it can be used to allow/disallow). Changed the format of rule options
-- Renamed `no-import-ignored` rule into `no-ignored` (the majority of the plugin rules are referred to `import` statements, so it is not necessary to specify it in the rule name)
-- Renamed `no-import-not-recognized-types` rule into `no-unknown`
-- Renamed `prefer-recognized-types` rule into `no-unknown-files`
-
-## [1.1.1] - 2020-12-11
-### Added
-- chore(deps): Add Node.js 10.x support while it is in maintenance
-
-### Changed
-- chore(ci-cd): Migrate build and publish pipelines to github actions
-- chore(deps): Update dependencies
-
-### Fixed
-- fix(#65): Fixed error on dependency scanning when dependencyInfo.name is null (thanks to @skurfuerst)
-
-## [1.1.0] - 2020-11-12
-### Added
-- feat(no-external): Allow forbid importing external libraries specifiers
-- chore(ci-cd): Add github workflows for publishing to gpr and check package version
-- chore(engines): Add node v15.x to engines
-
-### Fixed
-- fix(no-external): Do not allow importing subfolders of forbidden external libraries
-
-## [1.0.2] - 2020-10-18
-### Added
-- chore: Run tests on Windows OS in pipelines
-
-### Fixed
-- fix: Plugin was not working properly on Windows
-
-## [1.0.1] - 2020-08-27
-### Changed
-- chore: Update dependencies
-
-### Fixed
-- docs: Fix typo
-
-## [1.0.0] - 2020-06-13
-### Added
-- test(unit): Add unit tests
-- test(coverage): Increase coverage threshold to 100
-- feat(logs): Add chalk to warning logs
-
-### Changed
-- refactor: Remove duplicated code
-
-## [1.0.0-beta.3] - 2020-06-12
-### Fixed
-- fix(no-external): Fix no-external rule. There was an error reading options, so it was not being applied.
-- fix(prefer-recognized-types): Do not apply prefer-recognized-types rule to ignored files.
-- fix(rules): Ignore dependencies in all rules (except no-import-ignored) if they are marked as ignored
-
-## [1.0.0-beta.2] - 2020-06-11
-### Fixed
-- fix(helpers): Avoid error in helper when an element is not recognized
-
-## [1.0.0-beta.1] - 2020-06-11
-### Added
-- First pre-release