fix: module reasons when the module has layer (#1418)

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

Author: yifancong

packages/core/src/build-utils/build/module-graph/webpack/transform.ts

@@ -91,7 +91,8 @@ function appendDependency(
   const request = rawRequest ?? resolveRequest;
 
   if (!module.getDependencyByRequest(request)) {
-    const depModule = graph.getModuleByFile(resolveRequest)[0];
+    const depLayer = resolvedWebpackModule.layer || undefined;
+    const depModule = graph.getModuleByFile(resolveRequest, depLayer)[0];
 
     if (depModule) {
       const dep = module.addDependency(

packages/graph/src/graph/module-graph/graph.ts

@@ -324,11 +324,17 @@ export class ModuleGraph implements SDK.ModuleGraphInstance {
     return this._moduleWebpackIdMap.get(id);
   }
 
-  getModuleByFile(file: string) {
-    const similarModules = this.getModules().filter(
-      (item) => item.path === file,
-    );
-    return similarModules || [];
+  getModuleByFile(file: string, layer?: string) {
+    const similarModules = this.getModules().filter((item) => {
+      if (item.path !== file) {
+        return false;
+      }
+      if (layer !== undefined) {
+        return item.layer === layer;
+      }
+      return true;
+    });
+    return similarModules;
   }
 
   addModule(...modules: SDK.ModuleInstance[]) {

packages/graph/tests/module-graph.test.ts

@@ -1,6 +1,6 @@
 import path from 'path';
 import { expect, describe, it } from '@rstest/core';
-import type { SDK } from '@rsdoctor/types';
+import { SDK } from '@rsdoctor/types';
 import { Module, ModuleGraph, PackageGraph } from '../src/graph';
 // TODO: simplify the module-graph-basic.json data size.
 const resolveFixture = (...paths: string[]) => {
@@ -97,4 +97,138 @@ describe('module graph', () => {
 
     expect(_moduleGraph.toCodeData()).toMatchSnapshot();
   });
+
+  it('getModuleByFile should return modules by file path', async () => {
+    const moduleGraph = new ModuleGraph();
+    const filePath = '/path/to/module.js';
+
+    // Add module without layer
+    const module1 = new Module('1', filePath);
+    moduleGraph.addModule(module1);
+
+    // Add module with different file path
+    const module2 = new Module('2', '/path/to/other.js');
+    moduleGraph.addModule(module2);
+
+    const result = moduleGraph.getModuleByFile(filePath);
+    expect(result.length).toBe(1);
+    expect(result[0].id).toBe(module1.id);
+    expect(result[0].path).toBe(filePath);
+  });
+
+  it('getModuleByFile should return all modules when multiple modules have same path but different layers', async () => {
+    const moduleGraph = new ModuleGraph();
+    const filePath = '/path/to/module.js';
+
+    // Add module with layer 'legacy'
+    const moduleLegacy = new Module(
+      '1',
+      filePath,
+      false,
+      SDK.ModuleKind.Normal,
+      undefined,
+      'legacy',
+    );
+    moduleGraph.addModule(moduleLegacy);
+
+    // Add module with layer 'modern'
+    const moduleModern = new Module(
+      '2',
+      filePath,
+      false,
+      SDK.ModuleKind.Normal,
+      undefined,
+      'modern',
+    );
+    moduleGraph.addModule(moduleModern);
+
+    // Add module without layer
+    const moduleNoLayer = new Module('3', filePath);
+    moduleGraph.addModule(moduleNoLayer);
+
+    // When layer is not specified, should return all matching modules
+    const result = moduleGraph.getModuleByFile(filePath);
+    expect(result.length).toBe(3);
+    expect(result.map((m) => m.id).sort()).toEqual(
+      [moduleLegacy.id, moduleModern.id, moduleNoLayer.id].sort(),
+    );
+  });
+
+  it('getModuleByFile should filter by layer when layer parameter is provided', async () => {
+    const moduleGraph = new ModuleGraph();
+    const filePath = '/path/to/module.js';
+
+    // Add module with layer 'legacy'
+    const moduleLegacy = new Module(
+      '1',
+      filePath,
+      false,
+      SDK.ModuleKind.Normal,
+      undefined,
+      'legacy',
+    );
+    moduleGraph.addModule(moduleLegacy);
+
+    // Add module with layer 'modern'
+    const moduleModern = new Module(
+      '2',
+      filePath,
+      false,
+      SDK.ModuleKind.Normal,
+      undefined,
+      'modern',
+    );
+    moduleGraph.addModule(moduleModern);
+
+    // Add module without layer
+    const moduleNoLayer = new Module('3', filePath);
+    moduleGraph.addModule(moduleNoLayer);
+
+    // When layer 'legacy' is specified, should return only legacy module
+    const resultLegacy = moduleGraph.getModuleByFile(filePath, 'legacy');
+    expect(resultLegacy.length).toBe(1);
+    expect(resultLegacy[0].id).toBe(moduleLegacy.id);
+    expect(resultLegacy[0].layer).toBe('legacy');
+
+    // When layer 'modern' is specified, should return only modern module
+    const resultModern = moduleGraph.getModuleByFile(filePath, 'modern');
+    expect(resultModern.length).toBe(1);
+    expect(resultModern[0].id).toBe(moduleModern.id);
+    expect(resultModern[0].layer).toBe('modern');
+
+    // When layer is empty string, should return only module without layer
+    const resultNoLayer = moduleGraph.getModuleByFile(filePath, '');
+    expect(resultNoLayer.length).toBe(1);
+    expect(resultNoLayer[0].id).toBe(moduleNoLayer.id);
+    expect(resultNoLayer[0].layer).toBe('');
+  });
+
+  it('getModuleByFile should return empty array when no matching modules found', async () => {
+    const moduleGraph = new ModuleGraph();
+    const module = new Module('1', '/path/to/module.js');
+    moduleGraph.addModule(module);
+
+    const result = moduleGraph.getModuleByFile('/path/to/nonexistent.js');
+    expect(result).toEqual([]);
+  });
+
+  it('getModuleByFile should return empty array when layer does not match', async () => {
+    const moduleGraph = new ModuleGraph();
+    const filePath = '/path/to/module.js';
+
+    // Add module with layer 'legacy'
+    const moduleLegacy = new Module(
+      '1',
+      filePath,
+      false,
+      SDK.ModuleKind.Normal,
+      undefined,
+      'legacy',
+    );
+    moduleGraph.addModule(moduleLegacy);
+
+    // Query for 'modern' layer should return empty array
+    const result = moduleGraph.getModuleByFile(filePath, 'modern');
+    expect(result).toEqual([]);
+  });
 });

packages/types/src/sdk/module.ts

@@ -311,7 +311,7 @@ export interface ModuleGraphInstance {
   getModuleByWebpackId(webpackId: string): ModuleInstance | undefined;
 
   /** Get module by path */
-  getModuleByFile(file: string): ModuleInstance[] | [];
+  getModuleByFile(file: string, layer?: string): ModuleInstance[] | [];
 
   /** Add Module */
   addModule(module: ModuleInstance): void;