eslint-plugin-boundaries 3.1.1 → 3.3.0

package/README.md

@@ -261,7 +261,7 @@ Some rules require extra configuration, and it has to be defined in each specifi
 
 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.
 
-Options set an `allow` or `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.
+Options set an `allow` or `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 correspondent way, making it to produce an eslint error or not.
 
 ```jsonc
 {
@@ -277,6 +277,8 @@ Options set an `allow` or `disallow` value by default, and provide an array of r
           "from": ["helpers"],
           // ...disallow importing this type of elements
           "disallow": ["modules", "components"],
+          // ..for this kind of imports (applies only when using TypeScript)
+          "importKind": "value",
           // ...and return this custom error message
           "message": "Helpers must not import other thing than helpers"
         },
@@ -300,6 +302,7 @@ 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 analyzed 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.
+* __`importKind`__: `<string>` _Optional_. It is useful only when using TypeScript, as it allows to define if the rule applies when the dependency is being imported as a value or as a type. It can be also defined as an array of strings, or a micromatch pattern. Note that possible values to match with are `"value"`, `"type"` or `"typeof"`. For example, you could define that "components" can import "helpers" as a value, but not as a type. So, `import { helper } from "helpers/helper-a"` would be allowed, but `import type { Helper } from "helpers/helper-a"` would be disallowed.
 * __`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: Properties `from/target` and `disallow/allow` can receive a single matcher, or an array of matchers.
@@ -340,6 +343,7 @@ Available properties in error templates both from `file` or `dependency` are:
 * `internalPath`: File path being analyzed or imported. Relative to the element's root path.
 * `source`: Available only for `dependency`. The source of the `import` statement as it is in the code.
 * `parent`: If the element is child of another element, it is also available in this property, which contains correspondent `type`, `internalPath` and captured properties as well.
+* `importKind`: Available only for `dependency` when using TypeScript. It contains the kind of import being analyzed. Possible values are `"value"`, `"type"` or `"typeof"`.
 * ...All captured properties are also available
 
 > Tip: Read ["Global settings"](#global-settings) for further info about how to capture values from elements.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-boundaries",
-  "version": "3.1.1",
+  "version": "3.3.0",
   "description": "Eslint plugin checking architecture boundaries between elements",
   "keywords": [
     "eslint",
@@ -32,21 +32,24 @@
   },
   "dependencies": {
     "chalk": "4.1.2",
-    "eslint-import-resolver-node": "0.3.7",
-    "eslint-module-utils": "2.7.4",
-    "is-core-module": "2.11.0",
+    "eslint-import-resolver-node": "0.3.9",
+    "eslint-module-utils": "2.8.0",
+    "is-core-module": "2.13.0",
     "micromatch": "4.0.5"
   },
   "devDependencies": {
+    "@typescript-eslint/eslint-plugin": "6.4.0",
+    "@typescript-eslint/parser": "6.4.0",
     "cross-env": "7.0.3",
-    "eslint": "8.37.0",
-    "eslint-config-prettier": "8.8.0",
-    "eslint-plugin-prettier": "4.2.1",
+    "eslint": "8.47.0",
+    "eslint-config-prettier": "9.0.0",
+    "eslint-import-resolver-typescript": "3.6.0",
+    "eslint-plugin-prettier": "5.0.0",
     "husky": "8.0.3",
     "is-ci": "3.0.1",
-    "jest": "29.5.0",
-    "lint-staged": "13.2.0",
-    "prettier": "2.8.7"
+    "jest": "29.6.2",
+    "lint-staged": "14.0.0",
+    "prettier": "3.0.1"
   },
   "lint-staged": {
     "test/**/*.js": "eslint",

package/src/core/dependencyInfo.js

@@ -1,8 +1,7 @@
 const { fileInfo, importInfo } = require("./elementsInfo");
 
 function getParent(elementInfo) {
-  const parent = elementInfo.parents && elementInfo.parents[0];
-  return parent && parent.elementPath;
+  return elementInfo.parents?.[0]?.elementPath;
 }
 
 function getCommonAncestor(elementInfoA, elementInfoB) {
@@ -11,7 +10,7 @@ function getCommonAncestor(elementInfoA, elementInfoB) {
       return elementParentA.elementPath === elementParentB.elementPath;
     });
   });
-  return commonAncestor && commonAncestor.elementPath;
+  return commonAncestor?.elementPath;
 }
 
 function isUncle(elementA, elementB) {
@@ -65,12 +64,13 @@ function dependencyRelationship(dependency, element) {
   return null;
 }
 
-function dependencyInfo(source, context) {
+function dependencyInfo(source, importKind, context) {
   const elementInfo = fileInfo(context);
   const dependency = importInfo(source, context);
 
   return {
     ...dependency,
+    importKind: importKind || "value",
     relationship: dependencyRelationship(dependency, elementInfo),
     isInternal: isInternal(dependency, elementInfo),
   };

package/src/core/elementsInfo.js

@@ -9,10 +9,7 @@ const { isArray } = require("../helpers/utils");
 
 const { filesCache, importsCache, elementsCache } = require("./cache");
 
-function baseModule(name, path) {
-  if (path) {
-    return null;
-  }
+function baseModule(name) {
   if (isScoped(name)) {
     const [scope, packageName] = name.split("/");
     return `${scope}/${packageName}`;
@@ -129,12 +126,12 @@ function elementTypeAndParents(path, settings) {
                   path
                     .split("/")
                     .slice(0, path.split("/").length - lastSegmentMatching)
-                    .join("/")
+                    .join("/"),
                 );
               }
               const capture = micromatch.capture(
                 pattern,
-                useFullPathMatch ? path : accumulator.join("/")
+                useFullPathMatch ? path : accumulator.join("/"),
               );
 
               if (capture && basePatternCapture) {
@@ -174,7 +171,7 @@ function elementTypeAndParents(path, settings) {
         });
         return { accumulator, lastSegmentMatching };
       },
-      { accumulator: [], lastSegmentMatching: 0 }
+      { accumulator: [], lastSegmentMatching: 0 },
     );
 
   return {
@@ -193,6 +190,10 @@ function projectPath(absolutePath) {
   }
 }
 
+function externalModulePath(source, baseModuleValue) {
+  return source.replace(baseModuleValue, "");
+}
+
 function importInfo(source, context) {
   const path = projectPath(resolve(source, context));
   const isExternalModule = isExternal(source, path);
@@ -205,8 +206,9 @@ function importInfo(source, context) {
     result = resultCache;
   } else {
     elementCache = elementsCache.load(path, context.settings);
+    const baseModuleValue = isExternalModule ? baseModule(source) : null;
     const isBuiltInModule = isBuiltIn(source, path);
-    const pathToUse = isExternalModule ? null : path;
+    const pathToUse = isExternalModule ? externalModulePath(source, baseModuleValue) : path;
     if (elementCache) {
       elementResult = elementCache;
     } else {
@@ -221,7 +223,7 @@ function importInfo(source, context) {
       isLocal: !isExternalModule && !isBuiltInModule,
       isBuiltIn: isBuiltInModule,
       isExternal: isExternalModule,
-      baseModule: baseModule(source, pathToUse),
+      baseModule: baseModuleValue,
       ...elementResult,
     };
 

package/src/helpers/messages.js

@@ -22,7 +22,7 @@ function propertiesConcater(properties, index) {
 function micromatchPatternMessage(micromatchPatterns, elementCapturedValues) {
   const micromatchPatternsWithValues = micromatchPatternReplacingObjectsValues(
     micromatchPatterns,
-    { from: elementCapturedValues }
+    { from: elementCapturedValues },
   );
   if (isArray(micromatchPatternsWithValues)) {
     if (micromatchPatternsWithValues.length === 1) {
@@ -60,7 +60,7 @@ function elementMatcherMessage(elementMatcher, elementCapturedValues) {
   }
   return `${typeMessage(elementMatcher[0])}${capturedValuesMatcherMessage(
     elementMatcher[1],
-    elementCapturedValues
+    elementCapturedValues,
   )}`;
 }
 
@@ -85,6 +85,7 @@ function elementPropertiesToReplaceInTemplate(element) {
     type: element.type,
     internalPath: element.internalPath,
     source: element.source,
+    importKind: element.importKind,
   };
 }
 
@@ -92,39 +93,39 @@ function customErrorMessage(message, file, dependency, report = {}) {
   let replacedMessage = replaceObjectValuesInTemplates(
     replaceObjectValuesInTemplates(message, elementPropertiesToReplaceInTemplate(file), "file"),
     elementPropertiesToReplaceInTemplate(dependency),
-    "dependency"
+    "dependency",
   );
   replacedMessage = replaceObjectValuesInTemplates(
     replaceObjectValuesInTemplates(
       replacedMessage,
       elementPropertiesToReplaceInTemplate(file),
-      "from"
+      "from",
     ),
     elementPropertiesToReplaceInTemplate(dependency),
-    "target"
+    "target",
   );
   if (file.parents[0]) {
     replacedMessage = replaceObjectValuesInTemplates(
       replacedMessage,
       elementPropertiesToReplaceInTemplate(file.parents[0]),
-      "file.parent"
+      "file.parent",
     );
     replacedMessage = replaceObjectValuesInTemplates(
       replacedMessage,
       elementPropertiesToReplaceInTemplate(file.parents[0]),
-      "from.parent"
+      "from.parent",
     );
   }
   if (dependency.parents[0]) {
     replacedMessage = replaceObjectValuesInTemplates(
       replacedMessage,
       elementPropertiesToReplaceInTemplate(dependency.parents[0]),
-      "dependency.parent"
+      "dependency.parent",
     );
     replacedMessage = replaceObjectValuesInTemplates(
       replacedMessage,
       elementPropertiesToReplaceInTemplate(dependency.parents[0]),
-      "target.parent"
+      "target.parent",
     );
   }
   return replaceObjectValuesInTemplates(replacedMessage, report, "report");
@@ -148,13 +149,37 @@ function elementCapturedValuesMessage(capturedValues) {
 
 function elementMessage(elementInfo) {
   return `of type ${quote(elementInfo.type)}${elementCapturedValuesMessage(
-    elementInfo.capturedValues
+    elementInfo.capturedValues,
   )}`;
 }
 
+function hasToPrintKindMessage(ruleImportKind, dependencyInfo) {
+  return ruleImportKind && dependencyInfo.importKind;
+}
+
+function dependencyImportKindMessage(ruleImportKind, dependencyInfo) {
+  if (hasToPrintKindMessage(ruleImportKind, dependencyInfo)) {
+    return `kind ${quote(dependencyInfo.importKind)} from `;
+  }
+  return "";
+}
+
+function dependencyUsageKindMessage(
+  ruleImportKind,
+  dependencyInfo,
+  { suffix = " ", prefix = "" } = {},
+) {
+  if (hasToPrintKindMessage(ruleImportKind, dependencyInfo)) {
+    return `${prefix}${dependencyInfo.importKind}${suffix}`;
+  }
+  return "";
+}
+
 module.exports = {
   quote,
   ruleElementMessage,
   customErrorMessage,
   elementMessage,
+  dependencyImportKindMessage,
+  dependencyUsageKindMessage,
 };

package/src/helpers/rules.js

@@ -62,9 +62,12 @@ function micromatchPatternReplacingObjectsValues(pattern, object) {
 function isObjectMatch(objectWithMatchers, object, objectsWithValuesToReplace) {
   return Object.keys(objectWithMatchers).reduce((isMatch, key) => {
     if (isMatch) {
+      if (!object) {
+        return false;
+      }
       const micromatchPattern = micromatchPatternReplacingObjectsValues(
         objectWithMatchers[key],
-        objectsWithValuesToReplace
+        objectsWithValuesToReplace,
       );
       return micromatch.isMatch(object[key], micromatchPattern);
     }
@@ -76,17 +79,23 @@ function rulesMainKey(key) {
   return key || FROM;
 }
 
-function ruleMatch(ruleMatchers, targetElement, isMatch, fromElement) {
+function ruleMatch(ruleMatchers, targetElement, isMatch, fromElement, importKind) {
   let match = { result: false, report: null };
   const matchers = !isArray(ruleMatchers) ? [ruleMatchers] : ruleMatchers;
   matchers.forEach((matcher) => {
     if (!match.result) {
       if (isArray(matcher)) {
         const [value, captures] = matcher;
-        match = isMatch(targetElement, value, captures, {
-          from: fromElement.capturedValues,
-          target: targetElement.capturedValues,
-        });
+        match = isMatch(
+          targetElement,
+          value,
+          captures,
+          {
+            from: fromElement.capturedValues,
+            target: targetElement.capturedValues,
+          },
+          importKind,
+        );
       } else {
         match = isMatch(
           targetElement,
@@ -95,7 +104,8 @@ function ruleMatch(ruleMatchers, targetElement, isMatch, fromElement) {
           {
             from: fromElement.capturedValues,
             target: targetElement.capturedValues,
-          }
+          },
+          importKind,
         );
       }
     }
@@ -108,11 +118,11 @@ function isMatchElementKey(
   matcher,
   options,
   elementKey,
-  elementsToCompareCapturedValues
+  elementsToCompareCapturedValues,
 ) {
   const isMatch = micromatch.isMatch(
     elementInfo[elementKey],
-    micromatchPatternReplacingObjectsValues(matcher, elementsToCompareCapturedValues)
+    micromatchPatternReplacingObjectsValues(matcher, elementsToCompareCapturedValues),
   );
   if (isMatch && options) {
     return {
@@ -124,7 +134,23 @@ function isMatchElementKey(
   };
 }
 
-function isMatchElementType(elementInfo, matcher, options, elementsToCompareCapturedValues) {
+function isMatchImportKind(elementInfo, importKind) {
+  if (!elementInfo.importKind || !importKind) {
+    return true;
+  }
+  return micromatch.isMatch(elementInfo.importKind, importKind);
+}
+
+function isMatchElementType(
+  elementInfo,
+  matcher,
+  options,
+  elementsToCompareCapturedValues,
+  importKind,
+) {
+  if (!isMatchImportKind(elementInfo, importKind)) {
+    return { result: false };
+  }
   return isMatchElementKey(elementInfo, matcher, options, "type", elementsToCompareCapturedValues);
 }
 
@@ -166,11 +192,11 @@ function elementRulesAllowDependency({
   const [result, report, ruleReport] = getElementRules(
     elementToGetRulesFrom(element, dependency, mainKey),
     options,
-    mainKey
+    mainKey,
   ).reduce(
     (allowed, rule) => {
       if (rule.disallow) {
-        const match = ruleMatch(rule.disallow, dependency, isMatch, element);
+        const match = ruleMatch(rule.disallow, dependency, isMatch, element, rule.importKind);
         if (match.result) {
           return [
             false,
@@ -180,12 +206,13 @@ function elementRulesAllowDependency({
               disallow: rule.disallow,
               index: rule.index,
               message: rule.message || options.message,
+              importKind: rule.importKind,
             },
           ];
         }
       }
       if (rule.allow) {
-        const match = ruleMatch(rule.allow, dependency, isMatch, element);
+        const match = ruleMatch(rule.allow, dependency, isMatch, element, rule.importKind);
         if (match.result) {
           return [true, match.report];
         }
@@ -199,7 +226,7 @@ function elementRulesAllowDependency({
         isDefault: true,
         message: options.message,
       },
-    ]
+    ],
   );
   return {
     result,
@@ -218,4 +245,5 @@ module.exports = {
   getElementRules,
   rulesMainKey,
   micromatchPatternReplacingObjectsValues,
+  isMatchImportKind,
 };

package/src/helpers/utils.js

@@ -8,7 +8,8 @@ function isArray(object) {
 
 function replaceObjectValueInTemplate(template, key, value, namespace) {
   const keyToReplace = namespace ? `${namespace}.${key}` : key;
-  return template.replace(`\${${keyToReplace}}`, value);
+  const regexp = new RegExp(`\\$\\{${keyToReplace}\\}`, "g");
+  return template.replace(regexp, value);
 }
 
 function replaceObjectValuesInTemplates(strings, object, namespace) {

package/src/helpers/validations.js

@@ -63,6 +63,19 @@ function rulesOptionsSchema(options = {}) {
               [mainKey]: elementsMatcherSchema(),
               allow: elementsMatcherSchema(options.targetMatcherOptions),
               disallow: elementsMatcherSchema(options.targetMatcherOptions),
+              importKind: {
+                oneOf: [
+                  {
+                    type: "string",
+                  },
+                  {
+                    type: "array",
+                    items: {
+                      type: "string",
+                    },
+                  },
+                ],
+              },
               message: {
                 type: "string",
               },
@@ -109,7 +122,7 @@ function validateElements(elements) {
     // TODO, remove in next major version
     if (isLegacyType(element)) {
       warnOnce(
-        `Defining elements as strings in settings is deprecated. Will be automatically converted, but this feature will be removed in next major versions`
+        `Defining elements as strings in settings is deprecated. Will be automatically converted, but this feature will be removed in next major versions`,
       );
     } else {
       Object.keys(element).forEach(() => {
@@ -119,8 +132,8 @@ function validateElements(elements) {
         if (element.mode && !VALID_MODES.includes(element.mode)) {
           warnOnce(
             `Invalid mode property in '${ELEMENTS}' setting. Should be one of ${VALID_MODES.join(
-              ","
-            )}. Default value "${VALID_MODES[0]}" will be used instead`
+              ",",
+            )}. Default value "${VALID_MODES[0]}" will be used instead`,
           );
         }
         if (!element.pattern || !(isString(element.pattern) || isArray(element.pattern))) {
@@ -137,7 +150,7 @@ function validateElements(elements) {
 function deprecateAlias(aliases) {
   if (aliases) {
     warnOnce(
-      `Defining aliases in '${ALIAS}' setting is deprecated. Please use 'import/resolver' setting`
+      `Defining aliases in '${ALIAS}' setting is deprecated. Please use 'import/resolver' setting`,
     );
   }
 }

package/src/index.js

@@ -1,3 +1,4 @@
+const packageJson = require("../package.json");
 const rules = require("./constants/rules");
 const recommendedConfig = require("./configs/recommended");
 const strictConfig = require("./configs/strict");
@@ -17,6 +18,10 @@ const importRules = (ruleNames) => {
 // export all configs
 
 module.exports = {
+  meta: {
+    name: packageJson.name,
+    version: packageJson.version,
+  },
   rules: importRules(rules),
   configs: {
     recommended: recommendedConfig,

package/src/rules/element-types.js

@@ -8,7 +8,12 @@ const {
   isMatchElementType,
   elementRulesAllowDependency,
 } = require("../helpers/rules");
-const { customErrorMessage, ruleElementMessage, elementMessage } = require("../helpers/messages");
+const {
+  customErrorMessage,
+  ruleElementMessage,
+  elementMessage,
+  dependencyImportKindMessage,
+} = require("../helpers/messages");
 
 function elementRulesAllowDependencyType(element, dependency, options) {
   return elementRulesAllowDependency({
@@ -26,15 +31,18 @@ function errorMessage(ruleData, file, dependency) {
   }
   if (ruleReport.isDefault) {
     return `No rule allowing this dependency was found. File is ${elementMessage(
-      file
+      file,
     )}. Dependency is ${elementMessage(dependency)}`;
   }
-  return `Importing ${ruleElementMessage(
+  return `Importing ${dependencyImportKindMessage(
+    ruleReport.importKind,
+    dependency,
+  )}${ruleElementMessage(
     ruleReport.disallow,
-    file.capturedValues
+    file.capturedValues,
   )} is not allowed in ${ruleElementMessage(
     ruleReport.element,
-    file.capturedValues
+    file.capturedValues,
   )}. Disallowed in rule ${ruleReport.index + 1}`;
 }
 
@@ -55,5 +63,5 @@ module.exports = dependencyRule(
         });
       }
     }
-  }
+  },
 );

package/src/rules/entry-point.js

@@ -7,10 +7,25 @@ const {
   dependencyLocation,
   isMatchElementKey,
   elementRulesAllowDependency,
+  isMatchImportKind,
 } = require("../helpers/rules");
-const { customErrorMessage, ruleElementMessage, elementMessage } = require("../helpers/messages");
+const {
+  customErrorMessage,
+  ruleElementMessage,
+  elementMessage,
+  dependencyUsageKindMessage,
+} = require("../helpers/messages");
 
-function isMatchElementInternalPath(elementInfo, matcher, options, elementsCapturedValues) {
+function isMatchElementInternalPath(
+  elementInfo,
+  matcher,
+  options,
+  elementsCapturedValues,
+  importKind,
+) {
+  if (!isMatchImportKind(elementInfo, importKind)) {
+    return { result: false };
+  }
   return isMatchElementKey(elementInfo, matcher, options, "internalPath", elementsCapturedValues);
 }
 
@@ -36,8 +51,11 @@ function errorMessage(ruleData, file, dependency) {
   }
   return `The entry point '${dependency.internalPath}' is not allowed in ${ruleElementMessage(
     ruleReport.element,
-    dependency.capturedValues
-  )}. Disallowed in rule ${ruleReport.index + 1}`;
+    dependency.capturedValues,
+  )}${dependencyUsageKindMessage(ruleReport.importKind, dependency, {
+    prefix: " when importing ",
+    suffix: "",
+  })}. Disallowed in rule ${ruleReport.index + 1}`;
 }
 
 module.exports = dependencyRule(
@@ -62,5 +80,5 @@ module.exports = dependencyRule(
   },
   {
     validateRules: { onlyMainKey: true, mainKey: "target" },
-  }
+  },
 );

package/src/rules/external.js

@@ -9,19 +9,26 @@ const {
   dependencyLocation,
   elementRulesAllowDependency,
   micromatchPatternReplacingObjectsValues,
+  isMatchImportKind,
 } = require("../helpers/rules");
-const { customErrorMessage, ruleElementMessage, elementMessage } = require("../helpers/messages");
+const {
+  customErrorMessage,
+  ruleElementMessage,
+  elementMessage,
+  dependencyUsageKindMessage,
+} = require("../helpers/messages");
+const { isArray } = require("../helpers/utils");
 
-function specifiersMatch(specifiers, options, elementsCapturedValues) {
+function specifiersMatch(specifiers, specifierOptions, elementsCapturedValues) {
   const importedSpecifiersNames = specifiers
     .filter((specifier) => {
       return specifier.type === "ImportSpecifier" && specifier.imported.name;
     })
     .map((specifier) => specifier.imported.name);
-  return options.reduce((found, option) => {
+  return specifierOptions.reduce((found, option) => {
     const matcherWithTemplateReplaced = micromatchPatternReplacingObjectsValues(
       option,
-      elementsCapturedValues
+      elementsCapturedValues,
     );
     if (micromatch.some(importedSpecifiersNames, matcherWithTemplateReplaced)) {
       found.push(option);
@@ -30,21 +37,60 @@ function specifiersMatch(specifiers, options, elementsCapturedValues) {
   }, []);
 }
 
-function isMatchExternalDependency(dependency, matcher, options, elementsCapturedValues) {
+function pathMatch(path, pathOptions, elementsCapturedValues) {
+  const pathMatchers = isArray(pathOptions) ? pathOptions : [pathOptions];
+  return pathMatchers.reduce((isMatch, option) => {
+    if (isMatch) {
+      return isMatch;
+    }
+    const matcherWithTemplateReplaced = micromatchPatternReplacingObjectsValues(
+      option,
+      elementsCapturedValues,
+    );
+    if (micromatch.some(path, matcherWithTemplateReplaced)) {
+      isMatch = true;
+    }
+    return isMatch;
+  }, false);
+}
+
+function isMatchExternalDependency(
+  dependency,
+  matcher,
+  options,
+  elementsCapturedValues,
+  importKind,
+) {
   const matcherWithTemplatesReplaced = micromatchPatternReplacingObjectsValues(
     matcher,
-    elementsCapturedValues
+    elementsCapturedValues,
   );
+  if (!isMatchImportKind(dependency, importKind)) {
+    return { result: false };
+  }
   const isMatch = micromatch.isMatch(dependency.baseModule, matcherWithTemplatesReplaced);
   if (isMatch && options && Object.keys(options).length) {
-    const specifiersResult = specifiersMatch(
-      dependency.specifiers,
-      options.specifiers,
-      elementsCapturedValues
-    );
+    const isPathMatch = options.path
+      ? pathMatch(dependency.path, options.path, elementsCapturedValues)
+      : true;
+    if (isPathMatch && options.specifiers) {
+      const specifiersResult = specifiersMatch(
+        dependency.specifiers,
+        options.specifiers,
+        elementsCapturedValues,
+      );
+      return {
+        result: specifiersResult.length > 0,
+        report: {
+          specifiers: specifiersResult,
+        },
+      };
+    }
     return {
-      result: specifiersResult.length > 0,
-      report: specifiersResult,
+      result: isPathMatch,
+      report: {
+        path: dependency.path,
+      },
     };
   }
   return {
@@ -61,11 +107,19 @@ function elementRulesAllowExternalDependency(element, dependency, options) {
   });
 }
 
+function getErrorReportMessage(report) {
+  if (report.path) {
+    return report.path;
+  }
+  return report.specifiers.join(", ");
+}
+
 function errorMessage(ruleData, file, dependency) {
   const ruleReport = ruleData.ruleReport;
   if (ruleReport.message) {
     return customErrorMessage(ruleReport.message, file, dependency, {
-      specifiers: ruleData.report && ruleData.report.join(", "),
+      specifiers: ruleData.report?.specifiers?.join(", "),
+      path: ruleData.report?.path,
     });
   }
   if (ruleReport.isDefault) {
@@ -76,15 +130,20 @@ function errorMessage(ruleData, file, dependency) {
 
   const fileReport = `is not allowed in ${ruleElementMessage(
     ruleReport.element,
-    file.capturedValues
+    file.capturedValues,
   )}. Disallowed in rule ${ruleReport.index + 1}`;
 
   if (ruleData.report) {
-    return `Usage of '${ruleData.report.join(", ")}' from external module '${
+    return `Usage of ${dependencyUsageKindMessage(
+      ruleReport.importKind,
+      dependency,
+    )}'${getErrorReportMessage(ruleData.report)}' from external module '${
       dependency.baseModule
     }' ${fileReport}`;
   }
-  return `Usage of external module '${dependency.baseModule}' ${fileReport}`;
+  return `Usage of ${dependencyUsageKindMessage(ruleReport.importKind, dependency, {
+    suffix: " from ",
+  })}external module '${dependency.baseModule}' ${fileReport}`;
 }
 
 module.exports = dependencyRule(
@@ -101,6 +160,19 @@ module.exports = dependencyRule(
               type: "string",
             },
           },
+          path: {
+            oneOf: [
+              {
+                type: "string",
+              },
+              {
+                type: "array",
+                items: {
+                  type: "string",
+                },
+              },
+            ],
+          },
         },
         additionalProperties: false,
       },
@@ -111,7 +183,7 @@ module.exports = dependencyRule(
       const ruleData = elementRulesAllowExternalDependency(
         file,
         { ...dependency, specifiers: node.source.parent.specifiers },
-        options
+        options,
       );
       if (!ruleData.result) {
         context.report({
@@ -124,5 +196,5 @@ module.exports = dependencyRule(
   },
   {
     validateRules: { onlyMainKey: true },
-  }
+  },
 );

package/src/rules/no-ignored.js

@@ -20,5 +20,5 @@ module.exports = dependencyRule(
   },
   {
     validate: false,
-  }
+  },
 );

package/src/rules/no-private.js

@@ -40,7 +40,7 @@ module.exports = dependencyRule(
       dependency.relationship !== "internal" &&
       dependency.relationship !== "child" &&
       dependency.relationship !== "brother" &&
-      (!options || !options.allowUncles || dependency.relationship !== "uncle")
+      (!options?.allowUncles || dependency.relationship !== "uncle")
     ) {
       context.report({
         message: errorMessage(file, dependency, options),
@@ -51,5 +51,5 @@ module.exports = dependencyRule(
   },
   {
     validate: false,
-  }
+  },
 );

package/src/rules/no-unknown.js

@@ -20,5 +20,5 @@ module.exports = dependencyRule(
   },
   {
     validate: false,
-  }
+  },
 );

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

@@ -21,7 +21,7 @@ module.exports = function (ruleMeta, rule, ruleOptions = {}) {
 
       return {
         ImportDeclaration: (node) => {
-          const dependency = dependencyInfo(node.source.value, context);
+          const dependency = dependencyInfo(node.source.value, node.importKind, context);
 
           rule({ file, dependency, options, node, context });
         },