fix(enhanced): Populate buildMeta and buildInfo on ConsumeSharedPlugin using fallbacks

.vscode/launch.json

@@ -90,7 +90,6 @@
       "type": "node",
       "request": "launch",
       "preLaunchTask": "pnpm-build-enhanced",
-      "runtimeExecutable": "/Users/bytedance/.nvm/versions/node/v18.20.8/bin/node",
       "runtimeArgs": [
         "${workspaceFolder}/node_modules/jest/bin/jest.js",
         "test/ConfigTestCases.basictest.js",

packages/enhanced/src/lib/sharing/ConsumeSharedModule.ts

@@ -181,11 +181,37 @@ class ConsumeSharedModule extends Module {
       );
       if (this.options.eager) {
         this.addDependency(dep);
+        // We'll need to get the module from the fallback dependency
+        // later to copy its buildMeta and buildInfo
       } else {
         const block = new AsyncDependenciesBlock({});
         block.addDependency(dep);
         this.addBlock(block);
+        // Same here for async case
       }
+
+      // We need to hook into the compilation process to copy metadata
+      // after the fallback is fully built
+      compilation.hooks.finishModules.tap('ConsumeSharedModule', () => {
+        let dependency;
+
+        if (this.options.eager) {
+          // For eager mode, get the fallback directly
+          dependency = this.dependencies[0];
+        } else {
+          // For async mode, get it from the block
+          dependency = this.blocks[0]?.dependencies[0];
+        }
+
+        if (dependency) {
+          const fallback = compilation.moduleGraph.getModule(dependency);
+          if (fallback) {
+            // Copy its buildMeta and buildInfo from fallback module
+            this.buildMeta = { ...fallback.buildMeta };
+            this.buildInfo = { ...fallback.buildInfo };
+          }
+        }
+      });
     }
     callback();
   }

packages/enhanced/test/configCases/sharing/consume-nested/index.js

@@ -0,0 +1,4 @@
+it('should be able to consume nested modules', async () => {
+  const { default: main } = await import('package-1');
+  expect(main('test')).toEqual('test package-1 package-2');
+});

packages/enhanced/test/configCases/sharing/consume-nested/package.json

@@ -0,0 +1,7 @@
+{
+  "version": "1.0.0",
+  "dependencies": {
+    "package-2": "1.0.0",
+    "package-1": "1.0.0"
+  }
+}

packages/enhanced/test/configCases/sharing/consume-nested/webpack.config.js

@@ -0,0 +1,16 @@
+const { ModuleFederationPlugin } = require('../../../../dist/src');
+
+module.exports = {
+  mode: 'development',
+  devtool: false,
+  plugins: [
+    new ModuleFederationPlugin({
+      name: 'consume-nested',
+      filename: 'remoteEntry.js',
+      shared: {
+        'package-2': { version: '1.0.0' },
+        'package-1': { version: '1.0.0' },
+      },
+    }),
+  ],
+};

packages/enhanced/test/unit/sharing/ConsumeSharedModule.test.ts

@@ -265,6 +265,17 @@ describe('ConsumeSharedModule', () => {
 
   describe('build', () => {
     it('should add fallback dependency when import exists and eager=true', () => {
+      const mockCompilation = {
+        hooks: {
+          finishModules: {
+            tap: jest.fn(),
+          },
+        },
+        moduleGraph: {
+          getModule: jest.fn(),
+        },
+      };
+
       const module = new ConsumeSharedModule('/context', {
         ...testModuleOptions.eager,
         import: './react',
@@ -274,13 +285,30 @@ describe('ConsumeSharedModule', () => {
       function buildCallback() {
         // Empty callback needed for the build method
       }
-      module.build({} as any, {} as any, {} as any, {} as any, buildCallback);
+      module.build(
+        {} as any,
+        mockCompilation as any,
+        {} as any,
+        {} as any,
+        buildCallback,
+      );
 
       expect(module.dependencies.length).toBe(1);
       expect(module.blocks.length).toBe(0);
     });
 
     it('should add fallback in async block when import exists and eager=false', () => {
+      const mockCompilation = {
+        hooks: {
+          finishModules: {
+            tap: jest.fn(),
+          },
+        },
+        moduleGraph: {
+          getModule: jest.fn(),
+        },
+      };
+
       const module = new ConsumeSharedModule('/context', {
         ...testModuleOptions.basic,
         import: './react',
@@ -290,13 +318,30 @@ describe('ConsumeSharedModule', () => {
       function buildCallback() {
         // Empty callback needed for the build method
       }
-      module.build({} as any, {} as any, {} as any, {} as any, buildCallback);
+      module.build(
+        {} as any,
+        mockCompilation as any,
+        {} as any,
+        {} as any,
+        buildCallback,
+      );
 
       expect(module.dependencies.length).toBe(0);
       expect(module.blocks.length).toBe(1);
     });
 
     it('should not add fallback when import does not exist', () => {
+      const mockCompilation = {
+        hooks: {
+          finishModules: {
+            tap: jest.fn(),
+          },
+        },
+        moduleGraph: {
+          getModule: jest.fn(),
+        },
+      };
+
       const module = new ConsumeSharedModule('/context', {
         ...testModuleOptions.basic,
         import: undefined,
@@ -306,11 +351,68 @@ describe('ConsumeSharedModule', () => {
       function buildCallback() {
         // Empty callback needed for the build method
       }
-      module.build({} as any, {} as any, {} as any, {} as any, buildCallback);
+      module.build(
+        {} as any,
+        mockCompilation as any,
+        {} as any,
+        {} as any,
+        buildCallback,
+      );
 
       expect(module.dependencies.length).toBe(0);
       expect(module.blocks.length).toBe(0);
     });
+
+    it('should copy buildMeta and buildInfo from fallback', () => {
+      const mockFinishModulesHook = {
+        tap: jest.fn(),
+      };
+
+      const mockFallbackModule = {
+        buildMeta: { testMeta: 'value' },
+        buildInfo: { testInfo: 'data' },
+      };
+
+      const mockCompilation = {
+        hooks: {
+          finishModules: mockFinishModulesHook,
+        },
+        moduleGraph: {
+          getModule: jest.fn().mockReturnValue(mockFallbackModule),
+        },
+      };
+
+      const module = new ConsumeSharedModule('/context', {
+        ...testModuleOptions.eager,
+        import: './react',
+      } as any as ConsumeOptions);
+
+      // Named callback function to satisfy linter
+      function buildCallback() {
+        // Empty callback needed for the build method
+      }
+      module.build(
+        {} as any,
+        mockCompilation as any,
+        {} as any,
+        {} as any,
+        buildCallback,
+      );
+
+      // Verify the hook was tapped
+      expect(mockFinishModulesHook.tap).toHaveBeenCalledWith(
+        'ConsumeSharedModule',
+        expect.any(Function),
+      );
+
+      // Simulate the hook being called
+      const hookCallback = mockFinishModulesHook.tap.mock.calls[0][1];
+      hookCallback();
+
+      // Verify buildMeta and buildInfo were copied
+      expect(module.buildMeta).toEqual({ testMeta: 'value' });
+      expect(module.buildInfo).toEqual({ testInfo: 'data' });
+    });
   });
 
   describe('codeGeneration', () => {