dependency-cruiser 10.4.0-beta-2 → 10.4.0-beta-3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dependency-cruiser",
-  "version": "10.4.0-beta-2",
+  "version": "10.4.0-beta-3",
   "description": "Validate and visualize dependencies. With your rules. JavaScript, TypeScript, CoffeeScript. ES6, CommonJS, AMD.",
   "keywords": [
     "static analysis",

package/src/extract/resolve/determine-dependency-types.js

@@ -1,5 +1,4 @@
 const path = require("path");
-const { builtinModules } = require("module");
 const _has = require("lodash/has");
 const {
   isRelativeModuleName,
@@ -167,8 +166,8 @@ module.exports = function determineDependencyTypes(
 
   if (pDependency.couldNotResolve) {
     lReturnValue = ["unknown"];
-  } else if (builtinModules.includes(pModuleName)) {
-    // this 'isCore' business seems duplicate (it's already in
+  } else if (pDependency.coreModule) {
+    // this business seems duplicate (it's already in
     // the passed object as `coreModule`- determined by the resolve-AMD or
     // resolve-commonJS module). I want to deprecate the `coreModule`
     // attribute in favor of this one and determining it here will make

package/src/extract/resolve/index.js

@@ -142,7 +142,7 @@ module.exports = function resolve(
   pFileDirectory,
   pResolveOptions
 ) {
-  let lResolvedModule = resolveWithRetry(
+  let lResolvedDependency = resolveWithRetry(
     pDependency,
     pBaseDirectory,
     pFileDirectory,
@@ -152,16 +152,16 @@ module.exports = function resolve(
     pDependency.module
   );
 
-  lResolvedModule = {
-    ...lResolvedModule,
+  lResolvedDependency = {
+    ...lResolvedDependency,
     ...resolveHelpers.addLicenseAttribute(
       lStrippedModuleName,
-      lResolvedModule.resolved,
+      lResolvedDependency.resolved,
       { baseDirectory: pBaseDirectory, fileDirectory: pFileDirectory },
       pResolveOptions
     ),
     dependencyTypes: determineDependencyTypes(
-      { ...pDependency, ...lResolvedModule },
+      { ...pDependency, ...lResolvedDependency },
       lStrippedModuleName,
       getManifest(
         pFileDirectory,
@@ -176,11 +176,11 @@ module.exports = function resolve(
 
   if (
     !pResolveOptions.symlinks &&
-    !lResolvedModule.coreModule &&
-    !lResolvedModule.couldNotResolve
+    !lResolvedDependency.coreModule &&
+    !lResolvedDependency.couldNotResolve
   ) {
     try {
-      lResolvedModule.resolved = pathToPosix(
+      lResolvedDependency.resolved = pathToPosix(
         path.relative(
           pBaseDirectory,
           fs.realpathSync(
@@ -192,15 +192,15 @@ module.exports = function resolve(
                    again corresponds with a real file on disk
                  */
                 // eslint-disable-next-line no-control-regex
-                lResolvedModule.resolved.replace(/\u0000#/g, "#")
+                lResolvedDependency.resolved.replace(/\u0000#/g, "#")
               )
             )
           )
         )
       );
     } catch (pError) {
-      lResolvedModule.couldNotResolve = true;
+      lResolvedDependency.couldNotResolve = true;
     }
   }
-  return lResolvedModule;
+  return lResolvedDependency;
 };

package/src/main/utl/normalize-re-properties.js

@@ -10,6 +10,8 @@ const RE_PROPERTIES = [
   "licenseNot",
   "exoticRequire",
   "exoticRequireNot",
+  "via",
+  "viaNot",
 ];
 
 module.exports = function normalizeREProperties(

package/src/meta.js

@@ -1,7 +1,7 @@
 /* generated - don't edit */
 
 module.exports = {
-  version: "10.4.0-beta-2",
+  version: "10.4.0-beta-3",
   engines: {
     node: "^12.20||^14||>=16",
   },

package/src/schema/configuration.schema.js

@@ -162,6 +162,8 @@ module.exports = {
         moreThanOneDependencyType: { type: "boolean" },
         license: { $ref: "#/definitions/REAsStringsType" },
         licenseNot: { $ref: "#/definitions/REAsStringsType" },
+        via: { $ref: "#/definitions/REAsStringsType" },
+        viaNot: { $ref: "#/definitions/REAsStringsType" },
       },
     },
     DependentsModuleRestrictionType: {

package/src/schema/cruise-result.schema.js

@@ -334,6 +334,8 @@ module.exports = {
         moreThanOneDependencyType: { type: "boolean" },
         license: { $ref: "#/definitions/REAsStringsType" },
         licenseNot: { $ref: "#/definitions/REAsStringsType" },
+        via: { $ref: "#/definitions/REAsStringsType" },
+        viaNot: { $ref: "#/definitions/REAsStringsType" },
       },
     },
     DependentsModuleRestrictionType: {

package/src/validate/match-dependency-rule.js

@@ -37,6 +37,8 @@ function match(pFrom, pTo) {
       matchers.toLicenseNot(pRule, pTo) &&
       matchers.toExoticRequire(pRule, pTo) &&
       matchers.toExoticRequireNot(pRule, pTo) &&
+      matchers.toVia(pRule, pTo) &&
+      matchers.toViaNot(pRule, pTo) &&
       // preCompilationOnly is not a mandatory attribute, but if the attribute
       // is in the rule but not in the dependency there won't be a match
       // anyway, so we can use the default propertyEquals method regardless

package/src/validate/matchers.js

@@ -100,6 +100,22 @@ function toExoticRequireNot(pRule, pDependency) {
   );
 }
 
+function toViaNot(pRule, pDependency) {
+  return Boolean(
+    !pRule.to.viaNot ||
+      (pDependency.cycle &&
+        !pDependency.cycle.some((pVia) => pVia.match(pRule.to.viaNot)))
+  );
+}
+
+function toVia(pRule, pDependency) {
+  return Boolean(
+    !pRule.to.via ||
+      (pDependency.cycle &&
+        pDependency.cycle.some((pVia) => pVia.match(pRule.to.via)))
+  );
+}
+
 module.exports = {
   _replaceGroupPlaceholders,
   fromPath,
@@ -115,4 +131,6 @@ module.exports = {
   toLicenseNot,
   toExoticRequire,
   toExoticRequireNot,
+  toVia,
+  toViaNot,
 };

package/types/restrictions.d.ts

@@ -34,11 +34,18 @@ export interface IToRestriction extends IBaseRestrictionType {
    */
   circular?: boolean;
   /**
-   * If following this dependency will ultimately return to the source
-   * (circular === true), this attribute will contain an (ordered) array of module
-   * names that shows (one of the) circular path(s)
+   * For circular dependencies - whether or not to match cycles that include include modules
+   * with this regular expression. E.g. to allow all cycles, except when they go through one
+   * specific module. Typically to temporarily disallow some cycles with a lower severity -
+   * setting up a rule with a viaNot that ignores them.
    */
-  cycle?: string[];
+  via?: string | string[];
+  /**
+   * For circular dependencies - whether or not to match cycles that do NOT include modules
+   * with this regular expression. E.g. to disallow all cycles, except when they go through
+   * one specific module. Typically to temporarily allow some cycles until they're removed.
+   */
+  viaNot?: string | string[];
   /**
    * Whether or not to match when the dependency is a dynamic one.
    */