fix(enhanced): stabilize consume-shared runtime output (#4842)

Author: 2heal1

.changeset/stable-consume-shared-runtime.md

@@ -0,0 +1,5 @@
+---
+"@module-federation/enhanced": patch
+---
+
+Fix consume-shared runtime output ordering for stable build hashes.

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

@@ -11,6 +11,9 @@ import { getFederationGlobalScope } from '../container/runtime/utils';
 const { Template, RuntimeGlobals, RuntimeModule } = require(
   normalizeWebpackPath('webpack'),
 ) as typeof import('webpack');
+const { compareModulesByIdentifier } = require(
+  normalizeWebpackPath('webpack/lib/util/comparators'),
+) as typeof import('webpack/lib/util/comparators');
 
 class ConsumeSharedRuntimeModule extends RuntimeModule {
   private _runtimeRequirements: ReadonlySet<string>;
@@ -100,9 +103,10 @@ class ConsumeSharedRuntimeModule extends RuntimeModule {
 
     const allChunks = [...(this.chunk?.getAllReferencedChunks() || [])];
     for (const chunk of allChunks) {
-      const modules = chunkGraph.getChunkModulesIterableBySourceType(
+      const modules = chunkGraph.getOrderedChunkModulesIterableBySourceType(
         chunk,
         'consume-shared',
+        compareModulesByIdentifier,
       );
       if (!modules) continue;
       // chunk.id may equal 0
@@ -116,9 +120,10 @@ class ConsumeSharedRuntimeModule extends RuntimeModule {
       );
     }
     for (const chunk of [...(this.chunk?.getAllInitialChunks() || [])]) {
-      const modules = chunkGraph.getChunkModulesIterableBySourceType(
+      const modules = chunkGraph.getOrderedChunkModulesIterableBySourceType(
         chunk,
         'consume-shared',
+        compareModulesByIdentifier,
       );
       if (!modules) continue;
       addModules(modules, chunk, initialConsumes);

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

@@ -7,6 +7,12 @@ import { createMockCompilation, createWebpackMock, shareScopes } from './utils';
 // Use rs.hoisted() to create mock functions that are hoisted along with rs.mock()
 const mocks = rs.hoisted(() => ({
   mockNormalizeWebpackPath: rs.fn((path: string) => path),
+  mockCompareModulesByIdentifier: rs.fn(
+    (a: { identifier?: () => string }, b: { identifier?: () => string }) => {
+      if (!a.identifier || !b.identifier) return 0;
+      return a.identifier().localeCompare(b.identifier());
+    },
+  ),
 }));
 
 // Mock normalize-webpack-path
@@ -17,6 +23,10 @@ rs.mock('@module-federation/sdk/normalize-webpack-path', () => ({
 // Mock webpack - createWebpackMock already includes RuntimeModule with STAGE_* constants
 rs.mock('webpack', () => createWebpackMock());
 
+rs.mock('webpack/lib/util/comparators', () => ({
+  compareModulesByIdentifier: mocks.mockCompareModulesByIdentifier,
+}));
+
 // Import the real implementation
 import ConsumeSharedRuntimeModule from '../../../src/lib/sharing/ConsumeSharedRuntimeModule';
 
@@ -91,6 +101,14 @@ describe('ConsumeSharedRuntimeModule', () => {
   });
 
   describe('generate', () => {
+    const createChunk = (id: string | number) =>
+      ({
+        id,
+        ids: [],
+        runtime: 'runtime',
+        getAllInitialChunks: rs.fn().mockReturnValue([]),
+      }) as any;
+
     it('should generate code with string shareScope', () => {
       // Create a set of runtime requirements for the constructor
       const runtimeRequirements = new Set(['some-requirement']);
@@ -310,5 +328,107 @@ describe('ConsumeSharedRuntimeModule', () => {
       // The result might be null or a string
       expect(result === null || typeof result === 'string').toBeTruthy();
     });
+
+    it('should use ordered consume-shared modules for referenced and initial chunks', () => {
+      const runtimeRequirements = new Set(['some-requirement']);
+      const module = new ConsumeSharedRuntimeModule(runtimeRequirements);
+      const referencedChunk = createChunk('referenced');
+      const initialChunk = createChunk('initial');
+
+      module.chunk = {
+        id: 'test-chunk',
+        ids: [],
+        getAllReferencedChunks: rs.fn().mockReturnValue([referencedChunk]),
+        getAllInitialChunks: rs.fn().mockReturnValue([initialChunk]),
+      } as any;
+
+      mockCompilation.chunkGraph.getOrderedChunkModulesIterableBySourceType = rs
+        .fn()
+        .mockReturnValue([]);
+
+      module.compilation = mockCompilation as any;
+      module.chunkGraph = mockCompilation.chunkGraph as any;
+
+      expect(module.generate()).toBeNull();
+
+      expect(
+        mockCompilation.chunkGraph.getOrderedChunkModulesIterableBySourceType,
+      ).toHaveBeenCalledWith(
+        referencedChunk,
+        'consume-shared',
+        expect.any(Function),
+      );
+      expect(
+        mockCompilation.chunkGraph.getOrderedChunkModulesIterableBySourceType,
+      ).toHaveBeenCalledWith(
+        initialChunk,
+        'consume-shared',
+        expect.any(Function),
+      );
+      expect(
+        mockCompilation.chunkGraph.getChunkModulesIterableBySourceType,
+      ).not.toHaveBeenCalled();
+    });
+
+    it('should generate deterministic output when consume-shared insertion order changes', () => {
+      const createConsumeModule = (identifier: string, id: string) =>
+        ({
+          id,
+          identifier: () => identifier,
+        }) as any;
+      const moduleA = createConsumeModule('consume ./a', 'a');
+      const moduleB = createConsumeModule('consume ./b', 'b');
+
+      const generate = (modules: any[]) => {
+        const { mockCompilation: compilation } = createMockCompilation();
+        const runtimeRequirements = new Set(['__webpack_require__.f']);
+        const runtimeModule = new ConsumeSharedRuntimeModule(
+          runtimeRequirements,
+        );
+        const chunk = createChunk('async');
+
+        runtimeModule.chunk = {
+          id: 'test-chunk',
+          ids: [],
+          getAllReferencedChunks: rs.fn().mockReturnValue([chunk]),
+          getAllInitialChunks: rs.fn().mockReturnValue([chunk]),
+        } as any;
+
+        compilation.chunkGraph.getChunkModulesIterableBySourceType = rs
+          .fn()
+          .mockReturnValue(modules);
+        compilation.chunkGraph.getOrderedChunkModulesIterableBySourceType = rs
+          .fn()
+          .mockImplementation(
+            (
+              _chunk: unknown,
+              _sourceType: string,
+              compare: (a: unknown, b: unknown) => number,
+            ) => [...modules].sort(compare),
+          );
+        compilation.chunkGraph.getModuleId = rs.fn((m: any) => m.id);
+        compilation.codeGenerationResults.getSource = rs.fn((m: any) => ({
+          source: () => `fallback_${m.id}`,
+        }));
+        compilation.codeGenerationResults.getData = rs.fn((m: any) => ({
+          shareScope: 'default',
+          shareConfig: {
+            singleton: false,
+            requiredVersion: false,
+            strictVersion: false,
+            eager: false,
+            layer: null,
+          },
+          shareKey: m.id,
+        }));
+
+        runtimeModule.compilation = compilation as any;
+        runtimeModule.chunkGraph = compilation.chunkGraph as any;
+
+        return runtimeModule.generate();
+      };
+
+      expect(generate([moduleB, moduleA])).toBe(generate([moduleA, moduleB]));
+    });
   });
 });