feat(module-federation): enhance manifest generation and shared module handling (#12399)

Author: 2heal1

crates/rspack_plugin_mf/src/manifest/asset.rs

@@ -199,6 +199,10 @@ pub fn module_source_path(module: &BoxModule, compilation: &Compilation) -> Opti
   if let Some(pos) = identifier.find('?') {
     identifier.truncate(pos);
   }
+  // strip aggregated suffix like " + 1 modules"
+  if let Some((before, _)) = identifier.split_once(" + ") {
+    identifier = before.to_string();
+  }
   if identifier.starts_with("./") {
     identifier.drain(..2);
   }

crates/rspack_plugin_mf/src/manifest/data.rs

@@ -27,6 +27,8 @@ pub struct StatsBuildInfo {
 #[derive(Debug, Serialize, Clone)]
 pub struct StatsExpose {
   pub path: String,
+  #[serde(default)]
+  pub file: String,
   pub id: String,
   pub name: String,
   #[serde(default)]

crates/rspack_plugin_mf/src/manifest/mod.rs

@@ -150,6 +150,7 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
         let expose_name = expose.path.trim_start_matches("./").to_string();
         StatsExpose {
           path: expose.path.clone(),
+          file: String::new(),
           id: compose_id_with_separator(&container_name, &expose_name),
           name: expose_name,
           requires: Vec::new(),
@@ -166,7 +167,8 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
         name: shared.name.clone(),
         version: shared.version.clone().unwrap_or_default(),
         requiredVersion: shared.required_version.clone(),
-        singleton: shared.singleton,
+        // default singleton to true when not provided by user
+        singleton: shared.singleton.or(Some(true)),
         assets: StatsAssetsGroup::default(),
         usedIn: Vec::new(),
       })
@@ -207,6 +209,7 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
     };
 
     let mut exposes_map: HashMap<String, StatsExpose> = HashMap::default();
+    let mut expose_chunk_names: HashMap<String, String> = HashMap::default();
     let mut shared_map: HashMap<String, StatsShared> = HashMap::default();
     let mut shared_usage_links: Vec<(String, String)> = Vec::new();
     let mut shared_module_targets: HashMap<String, HashSet<ModuleIdentifier>> = HashMap::default();
@@ -253,13 +256,21 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
           };
           let id_comp = compose_id_with_separator(&container_name, &expose_name);
           let expose_file_key = strip_ext(import);
-          exposes_map.entry(expose_file_key).or_insert(StatsExpose {
-            path: expose_key.clone(),
-            id: id_comp,
-            name: expose_name,
-            requires: Vec::new(),
-            assets: StatsAssetsGroup::default(),
-          });
+          exposes_map
+            .entry(expose_file_key.clone())
+            .or_insert(StatsExpose {
+              path: expose_key.clone(),
+              file: String::new(),
+              id: id_comp,
+              name: expose_name,
+              requires: Vec::new(),
+              assets: StatsAssetsGroup::default(),
+            });
+          if let Some(n) = &options.name
+            && !n.is_empty()
+          {
+            expose_chunk_names.insert(expose_file_key, n.clone());
+          }
         }
         continue;
       }
@@ -277,6 +288,18 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
           if entry.version.is_empty() {
             entry.version = ver;
           }
+          // overlay user-configured shared options (singleton/requiredVersion/version)
+          if let Some(opt) = self.options.shared.iter().find(|s| s.name == pkg) {
+            if let Some(singleton) = opt.singleton {
+              entry.singleton = Some(singleton);
+            }
+            if entry.requiredVersion.is_none() {
+              entry.requiredVersion = opt.required_version.clone();
+            }
+            if let Some(cfg_ver) = opt.version.clone().filter(|_| entry.version.is_empty()) {
+              entry.version = cfg_ver;
+            }
+          }
           let targets = shared_module_targets.entry(pkg.clone()).or_default();
           for connection in module_graph.get_outgoing_connections(&module_identifier) {
             let referenced = *connection.module_identifier();
@@ -321,6 +344,19 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
         if entry.requiredVersion.is_none() && required.is_some() {
           entry.requiredVersion = required;
         }
+        // overlay user-configured shared options
+        if let Some(opt) = self.options.shared.iter().find(|s| s.name == pkg) {
+          if let Some(singleton) = opt.singleton {
+            entry.singleton = Some(singleton);
+          }
+          // prefer parsed requiredVersion but fill from config if still None
+          if entry.requiredVersion.is_none() {
+            entry.requiredVersion = opt.required_version.clone();
+          }
+          if let Some(cfg_ver) = opt.version.clone().filter(|_| entry.version.is_empty()) {
+            entry.version = cfg_ver;
+          }
+        }
         record_shared_usage(
           &mut shared_usage_links,
           &pkg,
@@ -395,14 +431,34 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
     }
 
     for (expose_file_key, expose) in exposes_map.iter_mut() {
-      let mut assets = if let Some(module_id) = module_ids_by_name.get(expose_file_key) {
-        collect_assets_for_module(compilation, module_id, &entry_point_names)
-          .unwrap_or_else(empty_assets_group)
-      } else if let Some(chunk_key) = compilation.named_chunks.get(expose_file_key) {
-        collect_assets_from_chunk(compilation, chunk_key, &entry_point_names)
-      } else {
-        empty_assets_group()
-      };
+      let mut assets = None;
+      if let Some(chunk_name) = expose_chunk_names.get(expose_file_key)
+        && let Some(chunk_key) = compilation.named_chunks.get(chunk_name)
+      {
+        assets = Some(collect_assets_from_chunk(
+          compilation,
+          chunk_key,
+          &entry_point_names,
+        ));
+      }
+      if assets.is_none()
+        && let Some(chunk_key) = compilation.named_chunks.get(expose_file_key)
+      {
+        assets = Some(collect_assets_from_chunk(
+          compilation,
+          chunk_key,
+          &entry_point_names,
+        ));
+      }
+      if assets.is_none()
+        && let Some(module_id) = module_ids_by_name.get(expose_file_key)
+      {
+        assets = collect_assets_for_module(compilation, module_id, &entry_point_names);
+      }
+      let mut assets = assets.unwrap_or_else(empty_assets_group);
+      if let Some(path) = expose_module_paths.get(expose_file_key) {
+        expose.file = path.clone();
+      }
       if !entry_name.is_empty() {
         assets.js.sync.retain(|asset| asset != &entry_name);
         assets.js.r#async.retain(|asset| asset != &entry_name);
@@ -441,6 +497,15 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
         .css
         .sync
         .retain(|asset| !shared_asset_files.contains(asset));
+      if !entry_name.is_empty() {
+        entry_assets.js.sync.retain(|asset| asset != &entry_name);
+        entry_assets.js.r#async.retain(|asset| asset != &entry_name);
+        entry_assets.css.sync.retain(|asset| asset != &entry_name);
+        entry_assets
+          .css
+          .r#async
+          .retain(|asset| asset != &entry_name);
+      }
       normalize_assets_group(&mut entry_assets);
       for expose in exposes_map.values_mut() {
         let is_empty = expose.assets.js.sync.is_empty()
@@ -487,7 +552,17 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
           (None, alias.clone())
         };
       let used_in =
-        collect_usage_files_for_module(compilation, module_graph, &module_id, &entry_point_names);
+        collect_usage_files_for_module(compilation, module_graph, &module_id, &entry_point_names)
+          // keep only the file path, drop aggregated suffix like " + 1 modules"
+          .into_iter()
+          .map(|s| {
+            if let Some((before, _)) = s.split_once(" + ") {
+              before.to_string()
+            } else {
+              s
+            }
+          })
+          .collect();
       remote_list.push(StatsRemote {
         alias: alias.clone(),
         consumingFederationContainerName: container_name.clone(),
@@ -509,6 +584,27 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
       .collect::<Vec<_>>();
     (exposes, shared, remote_list)
   };
+  // Ensure all configured remotes exist in stats, add missing with defaults
+  let mut remote_list = remote_list;
+  for (alias, target) in self.options.remote_alias_map.iter() {
+    if !remote_list.iter().any(|r| r.alias == *alias) {
+      let remote_container_name = if target.name.is_empty() {
+        alias.clone()
+      } else {
+        target.name.clone()
+      };
+      remote_list.push(StatsRemote {
+        alias: alias.clone(),
+        consumingFederationContainerName: container_name.clone(),
+        federationContainerName: remote_container_name.clone(),
+        // default moduleName to "." for missing entries
+        moduleName: ".".to_string(),
+        entry: target.entry.clone(),
+        usedIn: vec!["UNKNOWN".to_string()],
+      });
+    }
+  }
+
   let stats_root = StatsRoot {
     id: container_name.clone(),
     name: container_name.clone(),

crates/rspack_plugin_mf/src/manifest/utils.rs

@@ -43,7 +43,8 @@ pub fn ensure_shared_entry<'a>(
       name: pkg.to_string(),
       version: String::new(),
       requiredVersion: None,
-      singleton: None,
+      // default singleton to true
+      singleton: Some(true),
       assets: super::data::StatsAssetsGroup::default(),
       usedIn: Vec::new(),
     })
@@ -56,12 +57,19 @@ pub fn record_shared_usage(
   module_graph: &ModuleGraph,
   compilation: &Compilation,
 ) {
+  fn strip_aggregate_suffix(s: &str) -> String {
+    if let Some((before, _)) = s.split_once(" + ") {
+      before.to_string()
+    } else {
+      s.to_string()
+    }
+  }
   if let Some(issuer_module) = module_graph.get_issuer(module_identifier) {
     let issuer_name = issuer_module
       .readable_identifier(&compilation.options.context)
       .to_string();
     if !issuer_name.is_empty() {
-      let key = strip_ext(&issuer_name);
+      let key = strip_ext(&strip_aggregate_suffix(&issuer_name));
       shared_usage_links.push((pkg.to_string(), key));
     }
   }
@@ -80,7 +88,7 @@ pub fn record_shared_usage(
             .map(|dep| dep.request().to_string())
         });
       if let Some(request) = maybe_request {
-        let key = strip_ext(&request);
+        let key = strip_ext(&strip_aggregate_suffix(&request));
         shared_usage_links.push((pkg.to_string(), key));
       }
     }
@@ -90,14 +98,16 @@ pub fn record_shared_usage(
 pub fn parse_provide_shared_identifier(identifier: &str) -> Option<(String, String)> {
   let (before_request, _) = identifier.split_once(" = ")?;
   let token = before_request.split_whitespace().last()?;
-  let (name, version) = token.split_once('@')?;
+  // For scoped packages like @scope/pkg@1.0.0, split at the LAST '@'
+  let (name, version) = token.rsplit_once('@')?;
   Some((name.to_string(), version.to_string()))
 }
 
 pub fn parse_consume_shared_identifier(identifier: &str) -> Option<(String, Option<String>)> {
   let (_, rest) = identifier.split_once(") ")?;
   let token = rest.split_whitespace().next()?;
-  let (name, version) = token.split_once('@')?;
+  // For scoped packages like @scope/pkg@1.0.0, split at the LAST '@'
+  let (name, version) = token.rsplit_once('@')?;
   let version = version.trim();
   let required = if version.is_empty() || version == "*" {
     None