technical-debt-radar 1.7.1 → 1.9.0

package/dist/index.js

@@ -12889,6 +12889,7 @@ var require_boundary_checker = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.checkBoundaries = checkBoundaries;
     exports2._resetPathAliasCache = _resetPathAliasCache;
+    exports2._resetModuleParsingCache = _resetModuleParsingCache;
     var shared_1 = require_dist();
     var minimatch_1 = require_commonjs3();
     var ts_morph_1 = require("ts-morph");
@@ -13175,6 +13176,9 @@ var require_boundary_checker = __commonJS({
         const filePath = file.path;
         const sourceModule = findModuleForFile(filePath, policy);
         if (!sourceModule) {
+          if (isNestJSFramework(policy)) {
+            checkSharedFileImports(sourceFile, filePath, policy, input, violations);
+          }
           project.removeSourceFile(sourceFile);
           continue;
         }
@@ -13222,6 +13226,12 @@ var require_boundary_checker = __commonJS({
             continue;
           if (typeOnly)
             continue;
+          if (isNestJS) {
+            const importedNames = getImportedNamesFromSpecifier(sourceFile, specifier);
+            const suppressed = importedNames.length > 0 && importedNames.every((name) => isLegitimateNestJSModuleImport(sourceModule, targetModule, name, input));
+            if (suppressed)
+              continue;
+          }
           violations.push({
             category: "architecture",
             type: "module-boundary-violation",
@@ -13456,11 +13466,172 @@ var require_boundary_checker = __commonJS({
         return "src/" + specifier.slice(2);
       if (specifier.startsWith("~/"))
         return "src/" + specifier.slice(2);
+      if (specifier.startsWith("src/") || specifier.startsWith("lib/") || specifier.startsWith("app/")) {
+        return specifier;
+      }
       return void 0;
     }
     function _resetPathAliasCache() {
       _cachedAliases = void 0;
     }
+    var _cachedModuleParsing;
+    function parseNestJSModules(input) {
+      if (_cachedModuleParsing)
+        return _cachedModuleParsing;
+      const result = /* @__PURE__ */ new Map();
+      const project = new ts_morph_1.Project({ useInMemoryFileSystem: true });
+      for (const file of input.changedFiles) {
+        if (file.status === "deleted")
+          continue;
+        if (!/\.module\.(ts|js)$/.test(file.path))
+          continue;
+        const sf = project.createSourceFile(file.path, file.content);
+        for (const cls of sf.getClasses()) {
+          const moduleDecorator = cls.getDecorators().find((d) => d.getName() === "Module");
+          if (!moduleDecorator)
+            continue;
+          const className = cls.getName() ?? "";
+          const pathMatch = file.path.match(/src\/([^/]+)\//);
+          const moduleName = pathMatch ? pathMatch[1] : "";
+          if (!moduleName)
+            continue;
+          const callExpr = moduleDecorator.getCallExpression?.();
+          if (!callExpr)
+            continue;
+          const args = callExpr.getArguments();
+          if (args.length === 0 || !ts_morph_1.Node.isObjectLiteralExpression(args[0]))
+            continue;
+          const objLit = args[0];
+          const imports = [];
+          const exports3 = [];
+          const hasForwardRef = /* @__PURE__ */ new Map();
+          const importsProp = objLit.getProperty("imports");
+          if (importsProp && ts_morph_1.Node.isPropertyAssignment(importsProp)) {
+            const init = importsProp.getInitializer();
+            if (init && ts_morph_1.Node.isArrayLiteralExpression(init)) {
+              for (const el of init.getElements()) {
+                if (ts_morph_1.Node.isIdentifier(el)) {
+                  imports.push(el.getText());
+                  hasForwardRef.set(el.getText(), false);
+                } else if (ts_morph_1.Node.isCallExpression(el)) {
+                  const callText = el.getText();
+                  const fwdMatch = callText.match(/forwardRef\s*\(\s*\(\)\s*=>\s*(\w+)\s*\)/);
+                  if (fwdMatch) {
+                    imports.push(fwdMatch[1]);
+                    hasForwardRef.set(fwdMatch[1], true);
+                  } else {
+                    const expr = el.getExpression();
+                    if (ts_morph_1.Node.isPropertyAccessExpression(expr)) {
+                      const obj = expr.getExpression();
+                      if (ts_morph_1.Node.isIdentifier(obj)) {
+                        imports.push(obj.getText());
+                        hasForwardRef.set(obj.getText(), false);
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+          const exportsProp = objLit.getProperty("exports");
+          if (exportsProp && ts_morph_1.Node.isPropertyAssignment(exportsProp)) {
+            const init = exportsProp.getInitializer();
+            if (init && ts_morph_1.Node.isArrayLiteralExpression(init)) {
+              for (const el of init.getElements()) {
+                if (ts_morph_1.Node.isIdentifier(el)) {
+                  exports3.push(el.getText());
+                }
+              }
+            }
+          }
+          result.set(moduleName, { moduleName, className, imports, exports: exports3, hasForwardRef });
+        }
+        project.removeSourceFile(sf);
+      }
+      _cachedModuleParsing = result;
+      return result;
+    }
+    function getImportedNamesFromSpecifier(sourceFile, specifier) {
+      const names = [];
+      for (const decl of sourceFile.getImportDeclarations()) {
+        if (decl.getModuleSpecifierValue() !== specifier)
+          continue;
+        const defaultImport = decl.getDefaultImport();
+        if (defaultImport)
+          names.push(defaultImport.getText());
+        for (const named of decl.getNamedImports()) {
+          names.push(named.getName());
+        }
+      }
+      return names;
+    }
+    function isLegitimateNestJSModuleImport(sourceModuleName, targetModuleName, importedClassName, input) {
+      const modules = parseNestJSModules(input);
+      const importingMod = modules.get(sourceModuleName);
+      if (!importingMod)
+        return false;
+      const targetMod = modules.get(targetModuleName);
+      if (!targetMod)
+        return false;
+      const targetClassName = targetMod.className;
+      if (!importingMod.imports.includes(targetClassName))
+        return false;
+      if (importingMod.hasForwardRef.get(targetClassName))
+        return false;
+      if (!targetMod.exports.includes(importedClassName))
+        return false;
+      return true;
+    }
+    function _resetModuleParsingCache() {
+      _cachedModuleParsing = void 0;
+    }
+    function checkSharedFileImports(sourceFile, filePath, policy, input, violations) {
+      const basename2 = filePath.replace(/^.*\//, "");
+      if (/^(main|cli|bootstrap|server)\.(ts|js)$/.test(basename2))
+        return;
+      const normalizedPath = filePath.replace(/\\/g, "/");
+      const isSharedTypeFile = /\/(interfaces|types|shared|common|contracts)\//i.test(normalizedPath);
+      if (!isSharedTypeFile)
+        return;
+      for (const decl of sourceFile.getImportDeclarations()) {
+        const specifier = decl.getModuleSpecifierValue();
+        const line = decl.getStartLineNumber();
+        let resolvedTarget;
+        if (specifier.startsWith(".") || specifier.startsWith("/")) {
+          const sourceDir = filePath.replace(/\/[^/]+$/, "");
+          resolvedTarget = resolveRelativePath(sourceDir, specifier);
+        } else {
+          resolvedTarget = resolvePathAliasForBoundary(specifier, input);
+        }
+        if (!resolvedTarget)
+          continue;
+        const targetModule = findModuleForFile(resolvedTarget, policy);
+        if (!targetModule)
+          continue;
+        if (/\.module\.(ts|js)$/.test(resolvedTarget))
+          continue;
+        const targetBasename = resolvedTarget.replace(/^.*\//, "");
+        if (/\.(interface|dto|enum|types?)\.(ts|js)$/.test(targetBasename))
+          continue;
+        if (decl.isTypeOnly())
+          continue;
+        violations.push({
+          category: "architecture",
+          type: "module-boundary-violation",
+          ruleId: shared_1.ARCHITECTURE_RULES.MODULE_BOUNDARY,
+          severity: "critical",
+          source: "deterministic",
+          confidence: "high",
+          file: filePath,
+          line,
+          module: "shared",
+          message: `Shared file imports from "${targetModule}" module \u2014 shared files should not depend on feature modules (${filePath})`,
+          explanation: `Shared/interfaces files should contain plain types, not dependencies on feature module internals.`,
+          debtPoints: 5,
+          gateAction: "block"
+        });
+      }
+    }
     function normalizeForMatching(filePath) {
       let normalized = filePath.replace(/\\/g, "/");
       if (normalized.startsWith("/")) {
@@ -18746,7 +18917,7 @@ var require_dead_code_detector = __commonJS({
           const sf = sourceFiles.get(filePath);
           if (sf && exp.type === "class" && isNestJSDIRegistered(sf, exp.name))
             continue;
-          if (sf && isReferencedInOwnFile(sf, exp.name))
+          if (sf && !isTypeExport(exp.type) && isReferencedInOwnFile(sf, exp.name))
             continue;
           unusedExports.push({
             export: exp,
@@ -19103,6 +19274,8 @@ var require_dead_code_detector = __commonJS({
         for (const ext of extensions) {
           if (fp.endsWith(suffix + ext))
             return normalizeFilePath(fp);
+          if (fp.endsWith(suffix + "/index" + ext))
+            return normalizeFilePath(fp);
         }
       }
       return void 0;
@@ -19209,15 +19382,19 @@ var require_dead_code_detector = __commonJS({
             for (const [otherFilePath, otherText] of allFileTexts) {
               if (otherFilePath === filePath)
                 continue;
-              if (callPattern.test(otherText)) {
+              if (!callPattern.test(otherText))
+                continue;
+              const importPattern = new RegExp(`import\\s+.*\\b${className}\\b.*from\\s+`);
+              if (importPattern.test(otherText)) {
                 hasExternalCall = true;
                 break;
               }
             }
             if (!hasExternalCall) {
               const ownText = allFileTexts.get(filePath) ?? "";
-              const matches = ownText.match(new RegExp(`\\.${methodName}\\s*\\(`, "g"));
-              const internalCallCount = matches?.length ?? 0;
+              const selfCallPattern = new RegExp(`this\\.${methodName}\\s*\\(`, "g");
+              const selfCallMatches = ownText.match(selfCallPattern);
+              const internalCallCount = selfCallMatches?.length ?? 0;
               if (internalCallCount === 0) {
                 violations.push({
                   category: "maintainability",
@@ -19650,7 +19827,7 @@ var require_orchestrator = __commonJS({
         (0, reliability_detector_1.detectReliabilityIssues)(filteredInput, policy),
         (0, duplication_detector_1.detectDuplication)(filteredInput),
         projectRoot ? (0, missing_tests_detector_1.detectMissingTests)(filteredInput, projectRoot, buildMissingTestsConfig(policy)) : Promise.resolve(null),
-        (0, dead_code_detector_1.detectDeadCode)(filteredInput, {}, projectRoot),
+        (0, dead_code_detector_1.detectDeadCode)(filteredInput, { excludeBarrels: false, excludeTypes: false }, projectRoot),
         projectRoot ? Promise.resolve((0, coverage_delta_detector_1.detectCoverageDelta)(projectRoot)) : Promise.resolve(null)
       ]);
       const runtimeViolations = runtimeResult.violations;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "technical-debt-radar",
-  "version": "1.7.1",
+  "version": "1.9.0",
   "description": "Stop Node.js production crashes before merge. 47 detection patterns across 5 categories.",
   "bin": {
     "radar": "dist/index.js",