eslint-plugin-barrel-rules 1.4.2 → 1.4.4

package/README.ko.md

@@ -3,7 +3,7 @@
 # **Advanced Barrel Pattern Enforcement for JavaScript/TypeScript Projects**
 
 <div align="center">
-  <img src="https://img.shields.io/badge/version-1.4.2-blue.svg" alt="Version"/>
+  <img src="https://img.shields.io/badge/version-1.4.4-blue.svg" alt="Version"/>
   <img src="https://img.shields.io/badge/License-MIT-yellow.svg" alt="License"/>
   <img src="https://img.shields.io/badge/PRs-welcome-brightgreen.svg" alt="PRs Welcome"/>
 </div>

package/README.md

@@ -3,7 +3,7 @@
 # **Advanced Barrel Pattern Enforcement for JavaScript/TypeScript Projects**
 
 <div align="center">
-  <img src="https://img.shields.io/badge/version-1.4.2-blue.svg" alt="Version"/>
+  <img src="https://img.shields.io/badge/version-1.4.4-blue.svg" alt="Version"/>
   <img src="https://img.shields.io/badge/License-MIT-yellow.svg" alt="License"/>
   <img src="https://img.shields.io/badge/PRs-welcome-brightgreen.svg" alt="PRs Welcome"/>
 </div>

package/dist/index.cjs

@@ -42,8 +42,8 @@ var import_resolve = __toESM(require("resolve"), 1);
 // src/utils/glob.ts
 var import_fast_glob = __toESM(require("fast-glob"), 1);
 var Glob = class {
-  static resolvePath(path4, baseDir) {
-    const globResult = import_fast_glob.default.sync(path4, {
+  static resolvePath(path5, baseDir) {
+    const globResult = import_fast_glob.default.sync(path5, {
       cwd: baseDir,
       onlyDirectories: true,
       absolute: true
@@ -55,55 +55,125 @@ var Glob = class {
 // src/utils/alias.ts
 var import_tsconfig_paths = require("tsconfig-paths");
 var import_path = __toESM(require("path"), 1);
-var Alias = class {
+var Alias = class _Alias {
   constructor() {
   }
+  /**
+   * Resolves an alias path to an absolute file path
+   *
+   * @param rawPath - The alias path to resolve (e.g., "@entities/user", "@utils")
+   * @param currentFileDir - The directory of the current file (used to find tsconfig.json)
+   * @returns Result object with absolutePath and type ("success" or "fail")
+   *
+   * @example
+   * // With wildcard alias: "@entities/*" -> "src/entities/*"
+   * Alias.resolvePath("@entities/user", "/project/src/features")
+   * // Returns: { absolutePath: "/project/src/entities/user", type: "success" }
+   *
+   * @example
+   * // Without wildcard: "@utils" -> "src/utils/index"
+   * Alias.resolvePath("@utils", "/project/src/features")
+   * // Returns: { absolutePath: "/project/src/utils/index", type: "success" }
+   */
   static resolvePath(rawPath, currentFileDir) {
     try {
       const configResult = (0, import_tsconfig_paths.loadConfig)(currentFileDir);
-      if (configResult.resultType === "success") {
-        for (const [pattern, targets] of Object.entries(configResult.paths)) {
-          const origin = targets[0];
-          if (pattern.includes("*")) {
-            const patternRegex = new RegExp(
-              `^${pattern.replace("*", "(.*)")}$`
-            );
-            const match = rawPath.match(patternRegex);
-            if (match) {
-              const [, matchedPath] = match;
-              const extendedOrigin = origin.replace("*", matchedPath);
-              const absolutePath = import_path.default.resolve(
-                `${configResult.absoluteBaseUrl}/${extendedOrigin}`
-              );
-              return {
-                absolutePath,
-                type: "success"
-              };
-            }
-          } else {
-            if (rawPath === pattern) {
-              const absolutePath = import_path.default.resolve(
-                `${configResult.absoluteBaseUrl}/${origin}`
-              );
-              return {
-                absolutePath,
-                type: "success"
-              };
-            }
-          }
+      if (configResult.resultType !== "success") {
+        return this.createFailResult(rawPath);
+      }
+      const { paths, absoluteBaseUrl } = configResult;
+      for (const [aliasPattern, targetPaths] of Object.entries(paths)) {
+        const targetPath = targetPaths[0];
+        const matchResult = this.tryMatchPattern(
+          rawPath,
+          aliasPattern,
+          targetPath,
+          absoluteBaseUrl
+        );
+        if (matchResult) {
+          return matchResult;
         }
       }
-      return {
-        absolutePath: rawPath,
-        type: "fail"
-      };
-    } catch (e) {
-      return {
-        absolutePath: rawPath,
-        type: "fail"
-      };
+      return _Alias.createFailResult(rawPath);
+    } catch (error) {
+      return _Alias.createFailResult(rawPath);
+    }
+  }
+  /**
+   * Attempts to match a raw path against an alias pattern
+   *
+   * @param rawPath - The path to match (e.g., "@entities/user")
+   * @param aliasPattern - The alias pattern from tsconfig (e.g., "@entities/*")
+   * @param targetPath - The target path from tsconfig (e.g., "src/entities/*")
+   * @param baseUrl - The absolute base URL from tsconfig
+   * @returns Success result if matched, null otherwise
+   */
+  static tryMatchPattern(rawPath, aliasPattern, targetPath, baseUrl) {
+    const hasWildcard = aliasPattern.includes("*");
+    if (hasWildcard) {
+      return this.matchWildcardPattern(
+        rawPath,
+        aliasPattern,
+        targetPath,
+        baseUrl
+      );
+    } else {
+      return this.matchExactPattern(rawPath, aliasPattern, targetPath, baseUrl);
     }
   }
+  /**
+   * Matches a wildcard alias pattern (e.g., "@entities/*")
+   *
+   * Pattern: "@entities/*" -> Target: "src/entities/*"
+   * Input: "@entities/user" -> Matches: "user" -> Output: "src/entities/user"
+   *
+   * Note: The original implementation uses simple string replacement for regex,
+   * which works because alias patterns typically don't contain special regex chars.
+   * We maintain this behavior for compatibility.
+   */
+  static matchWildcardPattern(rawPath, aliasPattern, targetPath, baseUrl) {
+    const regexPattern = `^${aliasPattern.replace(/\*/g, "(.*)")}$`;
+    const regex = new RegExp(regexPattern);
+    const match = rawPath.match(regex);
+    if (!match) {
+      return null;
+    }
+    const capturedPath = match[1];
+    const resolvedTargetPath = targetPath.replace(/\*/g, capturedPath);
+    const absolutePath = import_path.default.resolve(`${baseUrl}/${resolvedTargetPath}`);
+    return _Alias.createSuccessResult(absolutePath);
+  }
+  /**
+   * Matches an exact alias pattern (no wildcard)
+   *
+   * Pattern: "@utils" -> Target: "src/utils/index"
+   * Input: "@utils" -> Output: "src/utils/index"
+   */
+  static matchExactPattern(rawPath, aliasPattern, targetPath, baseUrl) {
+    if (rawPath !== aliasPattern) {
+      return null;
+    }
+    const absolutePath = import_path.default.resolve(`${baseUrl}/${targetPath}`);
+    return _Alias.createSuccessResult(absolutePath);
+  }
+  /**
+   * Creates a success result
+   */
+  static createSuccessResult(absolutePath) {
+    return {
+      absolutePath,
+      type: "success"
+    };
+  }
+  /**
+   * Creates a fail result
+   */
+  static createFailResult(originalPath) {
+    return {
+      absolutePath: originalPath,
+      type: "fail"
+    };
+  }
 };
 
 // src/utils/constants.ts
@@ -229,16 +299,16 @@ var enforceBarrelPattern = {
           if (!rawImportPath.startsWith(".") && !rawImportPath.startsWith("/") || rawImportPath.includes("/node_modules/")) {
             return;
           }
-          absoluteImportPath = import_resolve.default.sync(rawImportPath, {
-            basedir: import_path2.default.dirname(absoluteCurrentFilePath),
-            extensions: RESOLVE_EXTENSIONS
-          });
+          try {
+            absoluteImportPath = import_resolve.default.sync(rawImportPath, {
+              basedir: import_path2.default.dirname(absoluteCurrentFilePath),
+              extensions: RESOLVE_EXTENSIONS
+            });
+          } catch (e) {
+            return;
+          }
         }
       } catch (e) {
-        context.report({
-          node,
-          messageId: "TransformedAliasResolveFailed"
-        });
         return;
       }
       {
@@ -252,8 +322,8 @@ var enforceBarrelPattern = {
             const targetPathEntryPointed = targetPathEntryPoints.includes(absoluteImportPath);
             const importedEnforceBarrelFile = absoluteImportPath.startsWith(closedTargetPath);
             const currentFileInEnforceBarrel = absoluteCurrentFilePath.startsWith(closedTargetPath);
-            const importedOutsideOfTargetPath = !currentFileInEnforceBarrel && importedEnforceBarrelFile;
-            const invalidImported = !targetPathEntryPointed && importedOutsideOfTargetPath;
+            const importedOutsideOfBarrel = !currentFileInEnforceBarrel && importedEnforceBarrelFile;
+            const invalidImported = !targetPathEntryPointed && importedOutsideOfBarrel;
             if (invalidImported) {
               matchedLatestTargetPath = absoluteTargetPath;
             }
@@ -325,13 +395,13 @@ var isolateBarrelFile = {
   create(context) {
     const option = context.options[0];
     const baseDir = option.baseDir;
-    const absoluteGlobalAllowPaths = option.globalAllowPaths.flatMap((path4) => {
-      return Glob.resolvePath(path4, baseDir);
+    const absoluteGlobalAllowPaths = option.globalAllowPaths.flatMap((path5) => {
+      return Glob.resolvePath(path5, baseDir);
     });
     const absoluteIsolations = option.isolations.flatMap((isolation) => {
       const isolationPaths = Glob.resolvePath(isolation.path, baseDir);
-      const allowedPaths = isolation.allowedPaths.flatMap((path4) => {
-        return Glob.resolvePath(path4, baseDir);
+      const allowedPaths = isolation.allowedPaths.flatMap((path5) => {
+        return Glob.resolvePath(path5, baseDir);
       });
       return isolationPaths.map((isolationPath) => ({
         isolationPath,
@@ -359,7 +429,7 @@ var isolateBarrelFile = {
               return;
             }
           } else {
-            if (!rawImportPath.startsWith(".") && !rawImportPath.startsWith("/")) {
+            if (!rawImportPath.startsWith(".") && !rawImportPath.startsWith("/") || rawImportPath.includes("/node_modules/")) {
               return;
             }
             absoluteImportPath = import_resolve2.default.sync(rawImportPath, {
@@ -374,31 +444,26 @@ var isolateBarrelFile = {
           });
           return;
         }
-        const isolationIndex = absoluteIsolations.findIndex((isolation) => {
-          const absoluteIsolationPath = isolation.isolationPath;
-          const closedIsolationPath = absoluteIsolationPath + "/";
-          return absoluteCurrentFilePath.startsWith(closedIsolationPath);
-        });
-        const matchedIsolation = absoluteIsolations[isolationIndex];
-        if (!matchedIsolation) return;
-        const isAllowedImport = matchedIsolation.allowedPaths.some(
-          (allowedPath) => {
-            const same = absoluteImportPath === allowedPath;
-            const closedAllowedPath = allowedPath + "/";
-            const sub = absoluteImportPath.startsWith(closedAllowedPath);
-            return same || sub;
-          }
-        );
-        const isGlobalAllowedImport = absoluteGlobalAllowPaths.some(
-          (allowedPath) => {
-            const same = absoluteImportPath === allowedPath;
-            const closedAllowedPath = allowedPath + "/";
-            const sub = absoluteImportPath.startsWith(closedAllowedPath);
-            return same || sub;
+        const matchedIsolationIndex = absoluteIsolations.findIndex(
+          (isolation) => {
+            const closedIsolationPath = isolation.isolationPath + "/";
+            return absoluteCurrentFilePath.startsWith(closedIsolationPath);
           }
         );
-        const allowedImport = isAllowedImport || isGlobalAllowedImport;
-        if (!allowedImport) {
+        const matchedIsolation = absoluteIsolations[matchedIsolationIndex];
+        if (!matchedIsolation) return;
+        const isAllowedImport = [
+          //global allowed import paths
+          ...absoluteGlobalAllowPaths,
+          //allowed import paths in the matched isolation
+          ...matchedIsolation.allowedPaths
+        ].some((allowedPath) => {
+          const same = absoluteImportPath === allowedPath;
+          const closedAllowedPath = allowedPath + "/";
+          const sub = absoluteImportPath.startsWith(closedAllowedPath);
+          return same || sub;
+        });
+        if (!isAllowedImport) {
           context.report({
             node,
             messageId: "IsolatedBarrelImportDisallowed"
@@ -447,12 +512,239 @@ var noWildcard = {
   }
 };
 
+// src/rules/no-cycle.ts
+var import_types4 = require("@typescript-eslint/types");
+var import_path4 = __toESM(require("path"), 1);
+var import_fs = __toESM(require("fs"), 1);
+var import_resolve3 = __toESM(require("resolve"), 1);
+var importGraph = /* @__PURE__ */ new Map();
+var barrelExportsCache = /* @__PURE__ */ new Map();
+function isBarrelFile(filePath) {
+  const fileName = import_path4.default.basename(filePath);
+  return BARREL_ENTRY_POINT_FILE_NAMES.includes(
+    fileName
+  );
+}
+function isExternalImport(rawPath) {
+  if (!rawPath.startsWith(".") && !rawPath.startsWith("/")) {
+    return true;
+  }
+  if (rawPath.includes("/node_modules/")) {
+    return true;
+  }
+  return false;
+}
+function resolveImportPath(rawImportPath, currentFileDir) {
+  try {
+    const aliasResult = Alias.resolvePath(rawImportPath, currentFileDir);
+    if (aliasResult.type === "success") {
+      return resolveAliasPath(aliasResult.absolutePath, currentFileDir);
+    }
+    if (isExternalImport(rawImportPath)) {
+      return null;
+    }
+    return import_resolve3.default.sync(rawImportPath, {
+      basedir: currentFileDir,
+      extensions: RESOLVE_EXTENSIONS
+    });
+  } catch (e) {
+    return null;
+  }
+}
+function resolveAliasPath(resolvedPath, currentFileDir) {
+  try {
+    const stats = import_fs.default.statSync(resolvedPath);
+    if (stats.isDirectory()) {
+      return import_resolve3.default.sync("index", {
+        basedir: resolvedPath,
+        extensions: RESOLVE_EXTENSIONS
+      });
+    }
+    return resolvedPath;
+  } catch (e) {
+    try {
+      return import_resolve3.default.sync(resolvedPath, {
+        basedir: currentFileDir,
+        extensions: RESOLVE_EXTENSIONS
+      });
+    } catch (e2) {
+      return resolvedPath;
+    }
+  }
+}
+function getBarrelExports(barrelFileDir, ast) {
+  const exports2 = [];
+  for (const statement of ast.body) {
+    if ((statement.type === "ExportNamedDeclaration" || statement.type === "ExportAllDeclaration") && statement.source) {
+      const exportPath = statement.source.value;
+      const resolved = tryResolve(exportPath, barrelFileDir);
+      if (resolved && !exports2.includes(resolved)) {
+        exports2.push(resolved);
+      }
+    }
+    if (statement.type === "ImportDeclaration" && statement.source) {
+      const importPath = statement.source.value;
+      if (importPath.startsWith(".") || importPath.startsWith("/")) {
+        const resolved = tryResolve(importPath, barrelFileDir);
+        if (resolved && !exports2.includes(resolved)) {
+          exports2.push(resolved);
+        }
+      }
+    }
+  }
+  return exports2;
+}
+function tryResolve(importPath, basedir) {
+  try {
+    return import_resolve3.default.sync(importPath, {
+      basedir,
+      extensions: RESOLVE_EXTENSIONS
+    });
+  } catch (e) {
+    return null;
+  }
+}
+function detectCycle(startFile, visited, recStack, currentPath) {
+  visited.add(startFile);
+  recStack.add(startFile);
+  currentPath.push(startFile);
+  const imports = importGraph.get(startFile) || /* @__PURE__ */ new Set();
+  for (const importedFile of imports) {
+    if (!visited.has(importedFile)) {
+      const cycle = detectCycle(importedFile, visited, recStack, [
+        ...currentPath
+      ]);
+      if (cycle) return cycle;
+    } else if (recStack.has(importedFile)) {
+      const cycleStart = currentPath.indexOf(importedFile);
+      return [...currentPath.slice(cycleStart), importedFile];
+    }
+  }
+  recStack.delete(startFile);
+  return null;
+}
+function hasBidirectionalCycle(fileA, fileB) {
+  var _a;
+  const bImports = importGraph.get(fileB);
+  return (_a = bImports == null ? void 0 : bImports.has(fileA)) != null ? _a : false;
+}
+function hasCycleThroughBarrel(currentFile, exportedModules) {
+  for (const exportedModule of exportedModules) {
+    if (exportedModule === currentFile) continue;
+    const moduleImports = importGraph.get(exportedModule);
+    if (moduleImports == null ? void 0 : moduleImports.has(currentFile)) {
+      return exportedModule;
+    }
+  }
+  return null;
+}
+var noCycle = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Detect circular dependencies and enforce relative imports in barrel files."
+    },
+    schema: [],
+    messages: {
+      CircularDependency: "Circular dependency detected: {{cyclePath}}. This creates a dependency cycle that can cause runtime errors and make code harder to maintain.",
+      BarrelInternalImportDisallowed: "Barrel files (index.ts) must use relative imports (./ or ../) for internal modules. Importing via barrel file or absolute path is not allowed. Use relative path: '{{relativePath}}'",
+      TransformedAliasResolveFailed: "Transformed alias resolve failed. please check the alias config."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    const currentFile = context.getFilename();
+    const currentDir = import_path4.default.dirname(currentFile);
+    if (!importGraph.has(currentFile)) {
+      importGraph.set(currentFile, /* @__PURE__ */ new Set());
+    }
+    importGraph.get(currentFile).clear();
+    if (isBarrelFile(currentFile)) {
+      const ast = context.getSourceCode().ast;
+      const exports2 = getBarrelExports(currentDir, ast);
+      barrelExportsCache.set(currentFile, exports2);
+    }
+    function checkImport(node) {
+      if (!node.source) return;
+      const rawPath = node.source.value;
+      const absolutePath = resolveImportPath(rawPath, currentDir);
+      if (!absolutePath) return;
+      if (isBarrelFile(currentFile)) {
+        const error = checkBarrelInternalImport(rawPath, absolutePath);
+        if (error) {
+          context.report({
+            node,
+            messageId: "BarrelInternalImportDisallowed",
+            data: { relativePath: error }
+          });
+          return;
+        }
+      }
+      const isBarrelInternal = isBarrelFile(currentFile) && absolutePath.startsWith(currentDir + import_path4.default.sep);
+      addToGraph(absolutePath);
+      if (isBarrelInternal) return;
+      const cycleError = checkForCycles(absolutePath);
+      if (cycleError) {
+        context.report({
+          node,
+          messageId: "CircularDependency",
+          data: { cyclePath: cycleError }
+        });
+      }
+    }
+    function checkBarrelInternalImport(rawPath, absolutePath) {
+      const isInternal = absolutePath.startsWith(currentDir + import_path4.default.sep) || absolutePath === currentDir;
+      if (!isInternal) return null;
+      if (rawPath.startsWith("./") || rawPath.startsWith("../")) {
+        return null;
+      }
+      const relative = import_path4.default.relative(currentDir, absolutePath);
+      const suggested = relative.startsWith(".") ? relative : `./${relative}`;
+      return suggested.replace(/\\/g, "/");
+    }
+    function addToGraph(absolutePath) {
+      const imports = importGraph.get(currentFile);
+      imports.add(absolutePath);
+      if (isBarrelFile(absolutePath)) {
+        const exports2 = barrelExportsCache.get(absolutePath) || [];
+        for (const exp of exports2) {
+          if (exp !== currentFile) {
+            imports.add(exp);
+          }
+        }
+      }
+    }
+    function checkForCycles(absolutePath) {
+      if (isBarrelFile(absolutePath)) {
+        const exports2 = barrelExportsCache.get(absolutePath) || [];
+        const cycleModule = hasCycleThroughBarrel(currentFile, exports2);
+        if (cycleModule) {
+          return `${currentFile} \u2192 ${absolutePath} \u2192 ${cycleModule} \u2192 ${absolutePath} \u2192 ${currentFile}`;
+        }
+      }
+      if (hasBidirectionalCycle(currentFile, absolutePath)) {
+        return `${currentFile} \u2192 ${absolutePath} \u2192 ${currentFile}`;
+      }
+      const cycle = detectCycle(currentFile, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set(), []);
+      if (cycle && cycle.length > 0) {
+        return cycle.join(" \u2192 ");
+      }
+      return null;
+    }
+    return {
+      ImportDeclaration: checkImport,
+      ExportNamedDeclaration: checkImport,
+      ExportAllDeclaration: checkImport
+    };
+  }
+};
+
 // src/index.ts
 var rules = {
   "enforce-barrel-pattern": enforceBarrelPattern,
   "isolate-barrel-file": isolateBarrelFile,
-  "no-wildcard": noWildcard
-  // "no-cycle": noCycle,
+  "no-wildcard": noWildcard,
+  "no-cycle": noCycle
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/index.d.cts

@@ -14,6 +14,7 @@ declare const rules: {
         globalAllowPaths: string[];
     }[], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
     "no-wildcard": _typescript_eslint_utils_ts_eslint.RuleModule<"NoWildcardImport" | "NoExportAll", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
+    "no-cycle": _typescript_eslint_utils_ts_eslint.RuleModule<"TransformedAliasResolveFailed" | "CircularDependency" | "BarrelInternalImportDisallowed", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
 };
 
 export { rules };

package/dist/index.d.ts

@@ -14,6 +14,7 @@ declare const rules: {
         globalAllowPaths: string[];
     }[], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
     "no-wildcard": _typescript_eslint_utils_ts_eslint.RuleModule<"NoWildcardImport" | "NoExportAll", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
+    "no-cycle": _typescript_eslint_utils_ts_eslint.RuleModule<"TransformedAliasResolveFailed" | "CircularDependency" | "BarrelInternalImportDisallowed", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
 };
 
 export { rules };

package/dist/index.js

@@ -6,8 +6,8 @@ import resolve from "resolve";
 // src/utils/glob.ts
 import FastGlob from "fast-glob";
 var Glob = class {
-  static resolvePath(path4, baseDir) {
-    const globResult = FastGlob.sync(path4, {
+  static resolvePath(path5, baseDir) {
+    const globResult = FastGlob.sync(path5, {
       cwd: baseDir,
       onlyDirectories: true,
       absolute: true
@@ -19,55 +19,125 @@ var Glob = class {
 // src/utils/alias.ts
 import { loadConfig } from "tsconfig-paths";
 import path from "path";
-var Alias = class {
+var Alias = class _Alias {
   constructor() {
   }
+  /**
+   * Resolves an alias path to an absolute file path
+   *
+   * @param rawPath - The alias path to resolve (e.g., "@entities/user", "@utils")
+   * @param currentFileDir - The directory of the current file (used to find tsconfig.json)
+   * @returns Result object with absolutePath and type ("success" or "fail")
+   *
+   * @example
+   * // With wildcard alias: "@entities/*" -> "src/entities/*"
+   * Alias.resolvePath("@entities/user", "/project/src/features")
+   * // Returns: { absolutePath: "/project/src/entities/user", type: "success" }
+   *
+   * @example
+   * // Without wildcard: "@utils" -> "src/utils/index"
+   * Alias.resolvePath("@utils", "/project/src/features")
+   * // Returns: { absolutePath: "/project/src/utils/index", type: "success" }
+   */
   static resolvePath(rawPath, currentFileDir) {
     try {
       const configResult = loadConfig(currentFileDir);
-      if (configResult.resultType === "success") {
-        for (const [pattern, targets] of Object.entries(configResult.paths)) {
-          const origin = targets[0];
-          if (pattern.includes("*")) {
-            const patternRegex = new RegExp(
-              `^${pattern.replace("*", "(.*)")}$`
-            );
-            const match = rawPath.match(patternRegex);
-            if (match) {
-              const [, matchedPath] = match;
-              const extendedOrigin = origin.replace("*", matchedPath);
-              const absolutePath = path.resolve(
-                `${configResult.absoluteBaseUrl}/${extendedOrigin}`
-              );
-              return {
-                absolutePath,
-                type: "success"
-              };
-            }
-          } else {
-            if (rawPath === pattern) {
-              const absolutePath = path.resolve(
-                `${configResult.absoluteBaseUrl}/${origin}`
-              );
-              return {
-                absolutePath,
-                type: "success"
-              };
-            }
-          }
+      if (configResult.resultType !== "success") {
+        return this.createFailResult(rawPath);
+      }
+      const { paths, absoluteBaseUrl } = configResult;
+      for (const [aliasPattern, targetPaths] of Object.entries(paths)) {
+        const targetPath = targetPaths[0];
+        const matchResult = this.tryMatchPattern(
+          rawPath,
+          aliasPattern,
+          targetPath,
+          absoluteBaseUrl
+        );
+        if (matchResult) {
+          return matchResult;
         }
       }
-      return {
-        absolutePath: rawPath,
-        type: "fail"
-      };
-    } catch (e) {
-      return {
-        absolutePath: rawPath,
-        type: "fail"
-      };
+      return _Alias.createFailResult(rawPath);
+    } catch (error) {
+      return _Alias.createFailResult(rawPath);
+    }
+  }
+  /**
+   * Attempts to match a raw path against an alias pattern
+   *
+   * @param rawPath - The path to match (e.g., "@entities/user")
+   * @param aliasPattern - The alias pattern from tsconfig (e.g., "@entities/*")
+   * @param targetPath - The target path from tsconfig (e.g., "src/entities/*")
+   * @param baseUrl - The absolute base URL from tsconfig
+   * @returns Success result if matched, null otherwise
+   */
+  static tryMatchPattern(rawPath, aliasPattern, targetPath, baseUrl) {
+    const hasWildcard = aliasPattern.includes("*");
+    if (hasWildcard) {
+      return this.matchWildcardPattern(
+        rawPath,
+        aliasPattern,
+        targetPath,
+        baseUrl
+      );
+    } else {
+      return this.matchExactPattern(rawPath, aliasPattern, targetPath, baseUrl);
     }
   }
+  /**
+   * Matches a wildcard alias pattern (e.g., "@entities/*")
+   *
+   * Pattern: "@entities/*" -> Target: "src/entities/*"
+   * Input: "@entities/user" -> Matches: "user" -> Output: "src/entities/user"
+   *
+   * Note: The original implementation uses simple string replacement for regex,
+   * which works because alias patterns typically don't contain special regex chars.
+   * We maintain this behavior for compatibility.
+   */
+  static matchWildcardPattern(rawPath, aliasPattern, targetPath, baseUrl) {
+    const regexPattern = `^${aliasPattern.replace(/\*/g, "(.*)")}$`;
+    const regex = new RegExp(regexPattern);
+    const match = rawPath.match(regex);
+    if (!match) {
+      return null;
+    }
+    const capturedPath = match[1];
+    const resolvedTargetPath = targetPath.replace(/\*/g, capturedPath);
+    const absolutePath = path.resolve(`${baseUrl}/${resolvedTargetPath}`);
+    return _Alias.createSuccessResult(absolutePath);
+  }
+  /**
+   * Matches an exact alias pattern (no wildcard)
+   *
+   * Pattern: "@utils" -> Target: "src/utils/index"
+   * Input: "@utils" -> Output: "src/utils/index"
+   */
+  static matchExactPattern(rawPath, aliasPattern, targetPath, baseUrl) {
+    if (rawPath !== aliasPattern) {
+      return null;
+    }
+    const absolutePath = path.resolve(`${baseUrl}/${targetPath}`);
+    return _Alias.createSuccessResult(absolutePath);
+  }
+  /**
+   * Creates a success result
+   */
+  static createSuccessResult(absolutePath) {
+    return {
+      absolutePath,
+      type: "success"
+    };
+  }
+  /**
+   * Creates a fail result
+   */
+  static createFailResult(originalPath) {
+    return {
+      absolutePath: originalPath,
+      type: "fail"
+    };
+  }
 };
 
 // src/utils/constants.ts
@@ -193,16 +263,16 @@ var enforceBarrelPattern = {
           if (!rawImportPath.startsWith(".") && !rawImportPath.startsWith("/") || rawImportPath.includes("/node_modules/")) {
             return;
           }
-          absoluteImportPath = resolve.sync(rawImportPath, {
-            basedir: path2.dirname(absoluteCurrentFilePath),
-            extensions: RESOLVE_EXTENSIONS
-          });
+          try {
+            absoluteImportPath = resolve.sync(rawImportPath, {
+              basedir: path2.dirname(absoluteCurrentFilePath),
+              extensions: RESOLVE_EXTENSIONS
+            });
+          } catch (e) {
+            return;
+          }
         }
       } catch (e) {
-        context.report({
-          node,
-          messageId: "TransformedAliasResolveFailed"
-        });
         return;
       }
       {
@@ -216,8 +286,8 @@ var enforceBarrelPattern = {
             const targetPathEntryPointed = targetPathEntryPoints.includes(absoluteImportPath);
             const importedEnforceBarrelFile = absoluteImportPath.startsWith(closedTargetPath);
             const currentFileInEnforceBarrel = absoluteCurrentFilePath.startsWith(closedTargetPath);
-            const importedOutsideOfTargetPath = !currentFileInEnforceBarrel && importedEnforceBarrelFile;
-            const invalidImported = !targetPathEntryPointed && importedOutsideOfTargetPath;
+            const importedOutsideOfBarrel = !currentFileInEnforceBarrel && importedEnforceBarrelFile;
+            const invalidImported = !targetPathEntryPointed && importedOutsideOfBarrel;
             if (invalidImported) {
               matchedLatestTargetPath = absoluteTargetPath;
             }
@@ -289,13 +359,13 @@ var isolateBarrelFile = {
   create(context) {
     const option = context.options[0];
     const baseDir = option.baseDir;
-    const absoluteGlobalAllowPaths = option.globalAllowPaths.flatMap((path4) => {
-      return Glob.resolvePath(path4, baseDir);
+    const absoluteGlobalAllowPaths = option.globalAllowPaths.flatMap((path5) => {
+      return Glob.resolvePath(path5, baseDir);
     });
     const absoluteIsolations = option.isolations.flatMap((isolation) => {
       const isolationPaths = Glob.resolvePath(isolation.path, baseDir);
-      const allowedPaths = isolation.allowedPaths.flatMap((path4) => {
-        return Glob.resolvePath(path4, baseDir);
+      const allowedPaths = isolation.allowedPaths.flatMap((path5) => {
+        return Glob.resolvePath(path5, baseDir);
       });
       return isolationPaths.map((isolationPath) => ({
         isolationPath,
@@ -323,7 +393,7 @@ var isolateBarrelFile = {
               return;
             }
           } else {
-            if (!rawImportPath.startsWith(".") && !rawImportPath.startsWith("/")) {
+            if (!rawImportPath.startsWith(".") && !rawImportPath.startsWith("/") || rawImportPath.includes("/node_modules/")) {
               return;
             }
             absoluteImportPath = resolve2.sync(rawImportPath, {
@@ -338,31 +408,26 @@ var isolateBarrelFile = {
           });
           return;
         }
-        const isolationIndex = absoluteIsolations.findIndex((isolation) => {
-          const absoluteIsolationPath = isolation.isolationPath;
-          const closedIsolationPath = absoluteIsolationPath + "/";
-          return absoluteCurrentFilePath.startsWith(closedIsolationPath);
-        });
-        const matchedIsolation = absoluteIsolations[isolationIndex];
-        if (!matchedIsolation) return;
-        const isAllowedImport = matchedIsolation.allowedPaths.some(
-          (allowedPath) => {
-            const same = absoluteImportPath === allowedPath;
-            const closedAllowedPath = allowedPath + "/";
-            const sub = absoluteImportPath.startsWith(closedAllowedPath);
-            return same || sub;
+        const matchedIsolationIndex = absoluteIsolations.findIndex(
+          (isolation) => {
+            const closedIsolationPath = isolation.isolationPath + "/";
+            return absoluteCurrentFilePath.startsWith(closedIsolationPath);
           }
         );
-        const isGlobalAllowedImport = absoluteGlobalAllowPaths.some(
-          (allowedPath) => {
-            const same = absoluteImportPath === allowedPath;
-            const closedAllowedPath = allowedPath + "/";
-            const sub = absoluteImportPath.startsWith(closedAllowedPath);
-            return same || sub;
-          }
-        );
-        const allowedImport = isAllowedImport || isGlobalAllowedImport;
-        if (!allowedImport) {
+        const matchedIsolation = absoluteIsolations[matchedIsolationIndex];
+        if (!matchedIsolation) return;
+        const isAllowedImport = [
+          //global allowed import paths
+          ...absoluteGlobalAllowPaths,
+          //allowed import paths in the matched isolation
+          ...matchedIsolation.allowedPaths
+        ].some((allowedPath) => {
+          const same = absoluteImportPath === allowedPath;
+          const closedAllowedPath = allowedPath + "/";
+          const sub = absoluteImportPath.startsWith(closedAllowedPath);
+          return same || sub;
+        });
+        if (!isAllowedImport) {
           context.report({
             node,
             messageId: "IsolatedBarrelImportDisallowed"
@@ -411,12 +476,239 @@ var noWildcard = {
   }
 };
 
+// src/rules/no-cycle.ts
+import "@typescript-eslint/types";
+import path4 from "path";
+import fs from "fs";
+import resolve3 from "resolve";
+var importGraph = /* @__PURE__ */ new Map();
+var barrelExportsCache = /* @__PURE__ */ new Map();
+function isBarrelFile(filePath) {
+  const fileName = path4.basename(filePath);
+  return BARREL_ENTRY_POINT_FILE_NAMES.includes(
+    fileName
+  );
+}
+function isExternalImport(rawPath) {
+  if (!rawPath.startsWith(".") && !rawPath.startsWith("/")) {
+    return true;
+  }
+  if (rawPath.includes("/node_modules/")) {
+    return true;
+  }
+  return false;
+}
+function resolveImportPath(rawImportPath, currentFileDir) {
+  try {
+    const aliasResult = Alias.resolvePath(rawImportPath, currentFileDir);
+    if (aliasResult.type === "success") {
+      return resolveAliasPath(aliasResult.absolutePath, currentFileDir);
+    }
+    if (isExternalImport(rawImportPath)) {
+      return null;
+    }
+    return resolve3.sync(rawImportPath, {
+      basedir: currentFileDir,
+      extensions: RESOLVE_EXTENSIONS
+    });
+  } catch (e) {
+    return null;
+  }
+}
+function resolveAliasPath(resolvedPath, currentFileDir) {
+  try {
+    const stats = fs.statSync(resolvedPath);
+    if (stats.isDirectory()) {
+      return resolve3.sync("index", {
+        basedir: resolvedPath,
+        extensions: RESOLVE_EXTENSIONS
+      });
+    }
+    return resolvedPath;
+  } catch (e) {
+    try {
+      return resolve3.sync(resolvedPath, {
+        basedir: currentFileDir,
+        extensions: RESOLVE_EXTENSIONS
+      });
+    } catch (e2) {
+      return resolvedPath;
+    }
+  }
+}
+function getBarrelExports(barrelFileDir, ast) {
+  const exports = [];
+  for (const statement of ast.body) {
+    if ((statement.type === "ExportNamedDeclaration" || statement.type === "ExportAllDeclaration") && statement.source) {
+      const exportPath = statement.source.value;
+      const resolved = tryResolve(exportPath, barrelFileDir);
+      if (resolved && !exports.includes(resolved)) {
+        exports.push(resolved);
+      }
+    }
+    if (statement.type === "ImportDeclaration" && statement.source) {
+      const importPath = statement.source.value;
+      if (importPath.startsWith(".") || importPath.startsWith("/")) {
+        const resolved = tryResolve(importPath, barrelFileDir);
+        if (resolved && !exports.includes(resolved)) {
+          exports.push(resolved);
+        }
+      }
+    }
+  }
+  return exports;
+}
+function tryResolve(importPath, basedir) {
+  try {
+    return resolve3.sync(importPath, {
+      basedir,
+      extensions: RESOLVE_EXTENSIONS
+    });
+  } catch (e) {
+    return null;
+  }
+}
+function detectCycle(startFile, visited, recStack, currentPath) {
+  visited.add(startFile);
+  recStack.add(startFile);
+  currentPath.push(startFile);
+  const imports = importGraph.get(startFile) || /* @__PURE__ */ new Set();
+  for (const importedFile of imports) {
+    if (!visited.has(importedFile)) {
+      const cycle = detectCycle(importedFile, visited, recStack, [
+        ...currentPath
+      ]);
+      if (cycle) return cycle;
+    } else if (recStack.has(importedFile)) {
+      const cycleStart = currentPath.indexOf(importedFile);
+      return [...currentPath.slice(cycleStart), importedFile];
+    }
+  }
+  recStack.delete(startFile);
+  return null;
+}
+function hasBidirectionalCycle(fileA, fileB) {
+  var _a;
+  const bImports = importGraph.get(fileB);
+  return (_a = bImports == null ? void 0 : bImports.has(fileA)) != null ? _a : false;
+}
+function hasCycleThroughBarrel(currentFile, exportedModules) {
+  for (const exportedModule of exportedModules) {
+    if (exportedModule === currentFile) continue;
+    const moduleImports = importGraph.get(exportedModule);
+    if (moduleImports == null ? void 0 : moduleImports.has(currentFile)) {
+      return exportedModule;
+    }
+  }
+  return null;
+}
+var noCycle = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Detect circular dependencies and enforce relative imports in barrel files."
+    },
+    schema: [],
+    messages: {
+      CircularDependency: "Circular dependency detected: {{cyclePath}}. This creates a dependency cycle that can cause runtime errors and make code harder to maintain.",
+      BarrelInternalImportDisallowed: "Barrel files (index.ts) must use relative imports (./ or ../) for internal modules. Importing via barrel file or absolute path is not allowed. Use relative path: '{{relativePath}}'",
+      TransformedAliasResolveFailed: "Transformed alias resolve failed. please check the alias config."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    const currentFile = context.getFilename();
+    const currentDir = path4.dirname(currentFile);
+    if (!importGraph.has(currentFile)) {
+      importGraph.set(currentFile, /* @__PURE__ */ new Set());
+    }
+    importGraph.get(currentFile).clear();
+    if (isBarrelFile(currentFile)) {
+      const ast = context.getSourceCode().ast;
+      const exports = getBarrelExports(currentDir, ast);
+      barrelExportsCache.set(currentFile, exports);
+    }
+    function checkImport(node) {
+      if (!node.source) return;
+      const rawPath = node.source.value;
+      const absolutePath = resolveImportPath(rawPath, currentDir);
+      if (!absolutePath) return;
+      if (isBarrelFile(currentFile)) {
+        const error = checkBarrelInternalImport(rawPath, absolutePath);
+        if (error) {
+          context.report({
+            node,
+            messageId: "BarrelInternalImportDisallowed",
+            data: { relativePath: error }
+          });
+          return;
+        }
+      }
+      const isBarrelInternal = isBarrelFile(currentFile) && absolutePath.startsWith(currentDir + path4.sep);
+      addToGraph(absolutePath);
+      if (isBarrelInternal) return;
+      const cycleError = checkForCycles(absolutePath);
+      if (cycleError) {
+        context.report({
+          node,
+          messageId: "CircularDependency",
+          data: { cyclePath: cycleError }
+        });
+      }
+    }
+    function checkBarrelInternalImport(rawPath, absolutePath) {
+      const isInternal = absolutePath.startsWith(currentDir + path4.sep) || absolutePath === currentDir;
+      if (!isInternal) return null;
+      if (rawPath.startsWith("./") || rawPath.startsWith("../")) {
+        return null;
+      }
+      const relative = path4.relative(currentDir, absolutePath);
+      const suggested = relative.startsWith(".") ? relative : `./${relative}`;
+      return suggested.replace(/\\/g, "/");
+    }
+    function addToGraph(absolutePath) {
+      const imports = importGraph.get(currentFile);
+      imports.add(absolutePath);
+      if (isBarrelFile(absolutePath)) {
+        const exports = barrelExportsCache.get(absolutePath) || [];
+        for (const exp of exports) {
+          if (exp !== currentFile) {
+            imports.add(exp);
+          }
+        }
+      }
+    }
+    function checkForCycles(absolutePath) {
+      if (isBarrelFile(absolutePath)) {
+        const exports = barrelExportsCache.get(absolutePath) || [];
+        const cycleModule = hasCycleThroughBarrel(currentFile, exports);
+        if (cycleModule) {
+          return `${currentFile} \u2192 ${absolutePath} \u2192 ${cycleModule} \u2192 ${absolutePath} \u2192 ${currentFile}`;
+        }
+      }
+      if (hasBidirectionalCycle(currentFile, absolutePath)) {
+        return `${currentFile} \u2192 ${absolutePath} \u2192 ${currentFile}`;
+      }
+      const cycle = detectCycle(currentFile, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set(), []);
+      if (cycle && cycle.length > 0) {
+        return cycle.join(" \u2192 ");
+      }
+      return null;
+    }
+    return {
+      ImportDeclaration: checkImport,
+      ExportNamedDeclaration: checkImport,
+      ExportAllDeclaration: checkImport
+    };
+  }
+};
+
 // src/index.ts
 var rules = {
   "enforce-barrel-pattern": enforceBarrelPattern,
   "isolate-barrel-file": isolateBarrelFile,
-  "no-wildcard": noWildcard
-  // "no-cycle": noCycle,
+  "no-wildcard": noWildcard,
+  "no-cycle": noCycle
 };
 export {
   rules

package/package.json

@@ -25,7 +25,7 @@
     "isolated barrel module",
     "no-wildcard"
   ],
-  "version": "1.4.2",
+  "version": "1.4.4",
   "type": "module",
   "main": "dist/index.cjs",
   "module": "dist/index.js",