fix: buildInfo rsc for builtin flight client entry plugin

Author: ahabhgk

crates/rspack_plugin_next_flight_client_entry/src/get_module_build_info.rs

@@ -1,8 +1,8 @@
 use rspack_core::Module;
+use serde::Deserialize;
 
-const CLIENT_MODULE_LABEL: &str =
-  r"/\* __next_internal_client_entry_do_not_use__ ([^ ]*) (cjs|auto) \*/";
-const ACTION_MODULE_LABEL: &str = r"/\* __next_internal_action_entry_do_not_use__ (\{[^}]+\}) \*/";
+const RSPACK_RSC_MODULE_INFORMATION: &str =
+  r"/\* __rspack_internal_rsc_module_information_do_not_use__ (\{[^}]+\}) \*/";
 
 const CLIENT_DIRECTIVE: &str = "use client";
 const SERVER_ACTION_DIRECTIVE: &str = "use server";
@@ -18,80 +18,27 @@ pub struct RSCModuleTypes {
   pub server: RSCModuleType,
 }
 
-#[derive(Default)]
+#[derive(Debug, Default, Deserialize)]
+#[serde(rename_all = "camelCase")]
 pub struct RSCMeta {
-  pub r#type: RSCModuleType,
+  pub r#type: String, // RSCModuleType
   pub actions: Option<Vec<String>>,
   pub action_ids: Option<std::collections::HashMap<String, String>>,
   pub client_refs: Option<Vec<String>>,
   pub client_entry_type: Option<String>,
   pub is_client_ref: bool,
 }
 
-fn get_rsc_module_information(source: &str, is_react_server_layer: bool) -> RSCMeta {
-  let actions_json = regex::Regex::new(ACTION_MODULE_LABEL)
+fn get_rsc_module_information(source: &str) -> Option<RSCMeta> {
+  regex::Regex::new(RSPACK_RSC_MODULE_INFORMATION)
     .unwrap()
     .captures(source)
-    .and_then(|caps| caps.get(1).map(|m| m.as_str()));
-  let parsed_actions_meta = actions_json
-    .map(|json| serde_json::from_str::<std::collections::HashMap<String, String>>(json).unwrap());
-  let actions = parsed_actions_meta
-    .as_ref()
-    .map(|meta| meta.values().cloned().collect());
-
-  let client_info_match = regex::Regex::new(CLIENT_MODULE_LABEL)
-    .unwrap()
-    .captures(source);
-  let is_client_ref = client_info_match.is_some();
-
-  if !is_react_server_layer {
-    return RSCMeta {
-      r#type: RSC_MODULE_TYPES.client,
-      actions,
-      action_ids: parsed_actions_meta,
-      client_refs: None,
-      client_entry_type: None,
-      is_client_ref,
-    };
-  }
-
-  let client_refs_string = client_info_match
-    .as_ref()
-    .and_then(|caps| caps.get(1).map(|m| m.as_str()));
-  let client_refs = client_refs_string.map(|s| s.split(',').map(String::from).collect());
-  let client_entry_type = client_info_match
-    .as_ref()
-    .and_then(|caps| caps.get(2).map(|m| m.as_str().to_string()));
-
-  let r#type = if client_info_match.is_some() {
-    RSC_MODULE_TYPES.client
-  } else {
-    RSC_MODULE_TYPES.server
-  };
-
-  RSCMeta {
-    r#type,
-    actions,
-    action_ids: parsed_actions_meta,
-    client_refs,
-    client_entry_type,
-    is_client_ref,
-  }
-}
-
-pub struct BuildInfo {
-  pub rsc: RSCMeta,
+    .and_then(|caps| caps.get(1).map(|m| m.as_str()))
+    .and_then(|info| serde_json::from_str(info).unwrap())
 }
 
-pub fn get_module_build_info(module: &dyn Module) -> BuildInfo {
-  let is_react_server_layer = module
-    .get_layer()
-    .is_some_and(|layer| layer == "react-server");
-
-  let rsc = module
+pub fn get_module_rsc_information(module: &dyn Module) -> Option<RSCMeta> {
+  module
     .original_source()
-    .map(|s| get_rsc_module_information(s.source().as_ref(), is_react_server_layer))
-    .unwrap_or_default();
-
-  BuildInfo { rsc }
+    .and_then(|s| get_rsc_module_information(s.source().as_ref()))
 }

crates/rspack_plugin_next_flight_client_entry/src/lib.rs

@@ -1,3 +1,5 @@
+#![feature(let_chains)]
+
 mod constants;
 mod for_each_entry_module;
 mod get_module_build_info;
@@ -20,7 +22,7 @@ use constants::{
 use derive_more::Debug;
 use for_each_entry_module::for_each_entry_module;
 use futures::future::BoxFuture;
-use get_module_build_info::get_module_build_info;
+use get_module_build_info::get_module_rsc_information;
 use is_metadata_route::is_metadata_route;
 use itertools::Itertools;
 use loader_util::{get_actions_from_build_info, is_client_component_entry_module, is_css_mod};
@@ -289,26 +291,31 @@ fn get_module_resource(module: &dyn Module) -> String {
 }
 
 pub fn get_assumed_source_type(module: &dyn Module, source_type: String) -> String {
-  let build_info = get_module_build_info(module);
-  let detected_client_entry_type = build_info.rsc.client_entry_type;
-  let client_refs = build_info.rsc.client_refs.unwrap_or(vec![]);
+  let rsc = get_module_rsc_information(module);
+  let detected_client_entry_type = rsc
+    .as_ref()
+    .and_then(|rsc| rsc.client_entry_type.as_deref());
+  let client_refs: &[String] = rsc
+    .as_ref()
+    .and_then(|rsc| rsc.client_refs.as_ref().map(|r| r.as_slice()))
+    .unwrap_or_default();
 
   // It's tricky to detect the type of a client boundary, but we should always
   // use the `module` type when we can, to support `export *` and `export from`
   // syntax in other modules that import this client boundary.
 
   if source_type == "auto" {
-    if detected_client_entry_type == Some("auto".to_string()) {
+    if detected_client_entry_type == Some("auto") {
       if client_refs.is_empty() {
         // If there's zero export detected in the client boundary, and it's the
         // `auto` type, we can safely assume it's a CJS module because it doesn't
         // have ESM exports.
         return "commonjs".to_string();
-      } else if !client_refs.contains(&"*".to_string()) {
+      } else if !client_refs.iter().any(|e| e == "*") {
         // Otherwise, we assume it's an ESM module.
         return "module".to_string();
       }
-    } else if detected_client_entry_type == Some("cjs".to_string()) {
+    } else if detected_client_entry_type == Some("cjs") {
       return "commonjs".to_string();
     }
   }
@@ -323,9 +330,9 @@ fn add_client_import(
   imported_identifiers: &[String],
   is_first_visit_module: bool,
 ) {
-  let build_info = get_module_build_info(module);
-  let client_entry_type = build_info.rsc.client_entry_type;
-  let is_cjs_module = client_entry_type == Some("cjs".to_string());
+  let rsc = get_module_rsc_information(module);
+  let client_entry_type = rsc.and_then(|rsc| rsc.client_entry_type);
+  let is_cjs_module = matches!(client_entry_type, Some(t) if t == "cjs");
   let assumed_source_type = get_assumed_source_type(
     module,
     if is_cjs_module {
@@ -1090,7 +1097,7 @@ impl FlightClientEntryPlugin {
         add_client_entry_and_ssr_modules_list.push(injected);
       }
 
-      if is_app_route_route(name.as_str()) {
+      if !is_app_route_route(name.as_str()) {
         // Create internal app
         add_client_entry_and_ssr_modules_list.push(self.inject_client_entry_and_ssr_modules(
           compilation,
@@ -1450,7 +1457,10 @@ async fn after_emit(&self, compilation: &mut Compilation) -> Result<()> {
           }
         }
       }
-
+      if mod_resource.contains("app/style.css") {
+        dbg!(module.get_layer());
+        dbg!(module.identifier());
+      }
       if module.get_layer().map(|layer| layer.as_str())
         != Some(WEBPACK_LAYERS.server_side_rendering)
       {
@@ -1500,6 +1510,18 @@ async fn after_emit(&self, compilation: &mut Compilation) -> Result<()> {
             ChunkGraph::get_module_id(&compilation.module_ids_artifact, *module_identifier)
           {
             record_module(module_id, module_identifier);
+
+            if let Some(module) = module_graph.module_by_identifier(module_identifier)
+              && let Some(module) = module.as_concatenated_module()
+            {
+              for m in module.get_modules() {
+                if let Some(module_id) =
+                  ChunkGraph::get_module_id(&compilation.module_ids_artifact, m.id)
+                {
+                  record_module(module_id, &m.id);
+                }
+              }
+            }
           }
         }
       }

crates/rspack_plugin_next_flight_client_entry/src/loader_util.rs

@@ -4,38 +4,33 @@ use lazy_regex::Lazy;
 use regex::Regex;
 use rspack_core::Module;
 
-use crate::get_module_build_info::{get_module_build_info, RSC_MODULE_TYPES};
+use crate::get_module_build_info::{get_module_rsc_information, RSC_MODULE_TYPES};
 
 // Gives { id: name } record of actions from the build info.
 pub fn get_actions_from_build_info(module: &dyn Module) -> Option<HashMap<String, String>> {
-  let build_info = get_module_build_info(module);
-  build_info.rsc.action_ids
+  let rsc = get_module_rsc_information(module)?;
+  rsc.action_ids
 }
 
 pub static REGEX_CSS: Lazy<Regex> = Lazy::new(|| Regex::new(r"\.(css|scss|sass)(\?.*)?$").unwrap());
 
 // This function checks if a module is able to emit CSS resources. You should
 // never only rely on a single regex to do that.
 pub fn is_css_mod(module: &dyn Module) -> bool {
+  if module.module_type().as_str() == "css/mini-extract" {
+    return true;
+  }
   let Some(module) = module.as_normal_module() else {
     return false;
   };
-
-  module.module_type().as_str() == "css/mini-extract"
-    || (REGEX_CSS.is_match(&module.resource_resolved_data().resource))
-
-  // TODO: rspack not support get loader request
-  // || module.loaders().iter().any(|loader| {
-  //   loader.loader.contains("next-style-loader/index.js")
-  //     || (std::env::var("NEXT_RSPACK").is_ok()
-  //       && loader
-  //         .loader
-  //         .contains("rspack.CssExtractRspackPlugin.loader"))
-  //     || loader.loader.contains("mini-css-extract-plugin/loader.js")
-  //     || loader
-  //       .loader
-  //       .contains("@vanilla-extract/webpack-plugin/loader/")
-  // })
+  REGEX_CSS.is_match(&module.resource_resolved_data().resource)
+    || module.loaders().iter().any(|loader| {
+      let loader_ident = loader.identifier();
+      loader_ident.contains("next-style-loader/index.js")
+        || loader_ident.contains("rspack.CssExtractRspackPlugin.loader")
+        || loader_ident.contains("mini-css-extract-plugin/loader.js")
+        || loader_ident.contains("@vanilla-extract/webpack-plugin/loader/")
+    })
 }
 
 pub static IMAGE_REGEX: Lazy<Regex> = Lazy::new(|| {
@@ -44,8 +39,8 @@ pub static IMAGE_REGEX: Lazy<Regex> = Lazy::new(|| {
 });
 
 pub fn is_client_component_entry_module(module: &dyn Module) -> bool {
-  let build_info = get_module_build_info(module);
-  let has_client_directive = build_info.rsc.is_client_ref;
+  let rsc = get_module_rsc_information(module);
+  let has_client_directive = matches!(rsc, Some(rsc) if rsc.is_client_ref);
   let is_action_layer_entry = is_action_client_layer_module(module);
   let is_image = if let Some(module) = module.as_normal_module() {
     IMAGE_REGEX.is_match(&module.resource_resolved_data().resource)
@@ -57,6 +52,7 @@ pub fn is_client_component_entry_module(module: &dyn Module) -> bool {
 
 // Determine if the whole module is client action, 'use server' in nested closure in the client module
 fn is_action_client_layer_module(module: &dyn Module) -> bool {
-  let build_info = get_module_build_info(module);
-  build_info.rsc.actions.is_some() && build_info.rsc.r#type == RSC_MODULE_TYPES.client
+  let rsc = get_module_rsc_information(module);
+  matches!(&rsc, Some(rsc) if rsc.actions.is_some())
+    && matches!(&rsc, Some(rsc) if rsc.r#type == RSC_MODULE_TYPES.client)
 }