fix(linter): allow for wildcards paths in enforce-module-boundaries rule (#34066)

closed #32190

## Current Behavior

eslint crashes when tsconfig.base.json path includes a * and you have an
import going to that project
## Expected Behavior
The plugin shouldn't crash and it should auto fix to a working import

## Related Issue(s)
<!-- Please link the issue being fixed so it gets closed when this is
merged. -->
#32190

Fixes #32190

(cherry picked from commit ac2ef1a)

Author: JesseZomer

packages/eslint-plugin/src/rules/enforce-module-boundaries.spec.ts

@@ -63,6 +63,7 @@ const tsconfig = {
       '@mycompany/domain2': ['libs/domain2/src/index.ts'],
       '@mycompany/buildableLib': ['libs/buildableLib/src/main.ts'],
       '@mycompany/buildableLib2': ['libs/buildableLib2/src/main.ts'],
+      '@mycompany/wildcard/*': ['libs/wildcard/*'],
       '@nonBuildableScope/nonBuildableLib': [
         'libs/nonBuildableLib/src/main.ts',
       ],
@@ -115,6 +116,8 @@ const fileSys = {
   './libs/dependsOnPrivate/src/index.ts': '',
   './libs/dependsOnPrivate2/src/index.ts': '',
   './libs/private/src/index.ts': '',
+  './libs/wildcard/user.ts': 'export class User {}',
+  './libs/wildcard/nested/user.ts': 'export class User {}',
   './tsconfig.base.json': JSON.stringify(tsconfig),
   './package.json': JSON.stringify(packageJson),
   './nx.json': JSON.stringify({ npmScope: 'happyorg' }),
@@ -1239,6 +1242,53 @@ Violation detected in:
         'External resources cannot be imported using a relative or absolute path'
       );
     });
+
+    it('should handle relative imports containing a wildcard', () => {
+      const failures = runRule(
+        {},
+        `${process.cwd()}/proj/libs/mylib/src/main.ts`,
+        `
+          import { User } from '../../wildcard/user';
+        `,
+        {
+          nodes: {
+            mylibName: {
+              name: 'mylibName',
+              type: 'lib',
+              data: {
+                root: 'libs/mylib',
+                tags: [],
+                implicitDependencies: [],
+                targets: {},
+              },
+            },
+            wildcardName: {
+              name: 'wildcardName',
+              type: 'lib',
+              data: {
+                root: 'libs/wildcard',
+                tags: [],
+                implicitDependencies: [],
+                targets: {},
+              },
+            },
+          },
+          dependencies: {},
+        },
+        {
+          mylibName: [createFile(`libs/mylib/src/main.ts`)],
+          wildcardName: [createFile('libs/wildcard/user.ts')],
+        }
+      );
+
+      expect(failures.length).toEqual(1);
+      expect(failures[0].message).toEqual(
+        'Projects cannot be imported by a relative or absolute path, and must begin with a npm scope'
+      );
+
+      // Verify the fix is available
+      expect(failures[0].fix).toBeDefined();
+    });
   });
 
   it('should error on absolute imports into libraries without using the npm scope', () => {

packages/eslint-plugin/src/rules/enforce-module-boundaries.ts

@@ -13,7 +13,7 @@ import {
 } from '@typescript-eslint/utils';
 import { isBuiltinModuleImport } from '@nx/js/src/internal';
 import { isRelativePath } from 'nx/src/utils/fileutils';
-import { basename, dirname, join, relative } from 'path';
+import { basename, dirname, join, relative, resolve } from 'path';
 import {
   getBarrelEntryPointByImportScope,
   getBarrelEntryPointProjectNode,
@@ -335,16 +335,50 @@ export default ESLintUtils.RuleCreator(
                 const importsToRemap = [];
 
                 for (const entryPointPath of indexTsPaths) {
+                  // Resolve wildcard paths before passing to getRelativeImportPath
+                  let resolvedPath = entryPointPath.path;
+                  let targetImportScope = entryPointPath.importScope;
+                  if (resolvedPath.includes('*')) {
+                    // For wildcard paths resolve using the actual file path from the relative import
+                    // Step 1: Resolve the relative import to an absolute path
+                    // Example: imp='../../models/user', fileName='/root/libs/mylib/src/main.ts'
+                    //          => absoluteImportPath='/root/libs/models/user'
+                    const absoluteImportPath = resolve(dirname(fileName), imp);
+
+                    // Step 2: Get the path relative to project path (which is the workspace root in practice)
+                    // Example: absoluteImportPath='/root/libs/models/user', projectPath='/root'
+                    //          => workspaceRelativePath='libs/models/user'
+                    const workspaceRelativePath = normalizePath(
+                      relative(projectPath, absoluteImportPath)
+                    );
+
+                    // Step 3: Extract the dynamic part after the base path
+                    // Example: resolvedPath='libs/models/*', workspaceRelativePath='libs/models/user'
+                    //          => basePath='libs/models/', dynamicPart='user'
+                    //          => resolvedPath='libs/models/user', targetImportScope='@myorg/models/user'
+                    const basePath = resolvedPath.replace('*', '');
+                    if (workspaceRelativePath.startsWith(basePath)) {
+                      const dynamicPart = workspaceRelativePath.substring(
+                        basePath.length
+                      );
+                      resolvedPath = resolvedPath.replace('*', dynamicPart);
+                      targetImportScope = targetImportScope.replace(
+                        '*',
+                        dynamicPart
+                      );
+                    }
+                  }
+
                   for (const importMember of imports) {
                     const importPath = getRelativeImportPath(
                       importMember,
-                      join(workspaceRoot, entryPointPath.path)
+                      join(workspaceRoot, resolvedPath)
                     );
                     // we cannot remap, so leave it as is
                     if (importPath) {
                       importsToRemap.push({
                         member: importMember,
-                        importPath: entryPointPath.importScope,
+                        importPath: targetImportScope,
                       });
                     }
                   }