fix: import-module should use separate plugin driver

crates/node_binding/src/lib.rs

@@ -69,6 +69,7 @@ impl Rspack {
     let rspack = rspack_core::Compiler::new(
       compiler_options,
       plugins,
+      rspack_binding_options::buildtime_plugins::buildtime_plugins(),
       Some(Box::new(
         AsyncNodeWritableFileSystem::new(output_filesystem)
           .map_err(|e| Error::from_reason(format!("Failed to create writable filesystem: {e}",)))?,

crates/rspack_binding_options/src/lib.rs

@@ -3,4 +3,5 @@
 mod options;
 mod plugins;
 pub use options::*;
+pub use plugins::buildtime_plugins;
 pub(crate) use plugins::*;

crates/rspack_binding_options/src/plugins/buildtime_plugins.rs

@@ -0,0 +1,15 @@
+use rspack_core::{BoxPlugin, ChunkLoading, ChunkLoadingType, PluginExt};
+use rspack_plugin_javascript::JsPlugin;
+use rspack_plugin_runtime::{
+  CommonJsChunkLoadingPlugin, RuntimePlugin, StartupChunkDependenciesPlugin,
+};
+
+pub fn buildtime_plugins() -> Vec<BoxPlugin> {
+  vec![
+    RuntimePlugin::default().boxed(),
+    JsPlugin::default().boxed(),
+    // StartupChunkDependenciesPlugin::new(ChunkLoading::Enable(ChunkLoadingType::Require), false)
+    //   .boxed(),
+    // CommonJsChunkLoadingPlugin::new(false).boxed(),
+  ]
+}

crates/rspack_binding_options/src/plugins/mod.rs

@@ -3,3 +3,4 @@ mod js_loader;
 
 pub use context_replacement::*;
 pub(super) use js_loader::{JsLoaderRspackPlugin, JsLoaderRunner};
+pub mod buildtime_plugins;

crates/rspack_core/src/compiler/mod.rs

@@ -61,6 +61,7 @@ pub struct Compiler {
   pub input_filesystem: Arc<dyn ReadableFileSystem>,
   pub compilation: Compilation,
   pub plugin_driver: SharedPluginDriver,
+  pub buildtime_plugin_driver: SharedPluginDriver,
   pub resolver_factory: Arc<ResolverFactory>,
   pub loader_resolver_factory: Arc<ResolverFactory>,
   pub old_cache: Arc<OldCache>,
@@ -75,6 +76,7 @@ impl Compiler {
   pub fn new(
     options: CompilerOptions,
     plugins: Vec<BoxPlugin>,
+    buildtime_plugins: Vec<BoxPlugin>,
     output_filesystem: Option<Box<dyn AsyncWritableFileSystem + Send + Sync>>,
     // only supports passing input_filesystem in rust api, no support for js api
     input_filesystem: Option<Arc<dyn ReadableFileSystem + Send + Sync>>,
@@ -102,8 +104,11 @@ impl Compiler {
         input_filesystem.clone(),
       ))
     });
+
     let options = Arc::new(options);
     let plugin_driver = PluginDriver::new(options.clone(), plugins, resolver_factory.clone());
+    let buildtime_plugin_driver =
+      PluginDriver::new(options.clone(), buildtime_plugins, resolver_factory.clone());
     let old_cache = Arc::new(OldCache::new(options.clone()));
     let unaffected_modules_cache = Arc::new(UnaffectedModulesCache::default());
     let module_executor = ModuleExecutor::default();
@@ -126,6 +131,7 @@ impl Compiler {
       ),
       output_filesystem,
       plugin_driver,
+      buildtime_plugin_driver,
       resolver_factory,
       loader_resolver_factory,
       old_cache,

crates/rspack_core/src/compiler/module_executor/entry.rs

@@ -52,11 +52,11 @@ impl Task<MakeTaskContext> for EntryTask {
               )
             })
             .clone(),
-          original_module_identifier: None,
+          original_module_identifier: dep.original_module,
           original_module_source: None,
           issuer: None,
           issuer_layer: None,
-          original_module_context: None,
+          original_module_context: Some(Box::new(dep.context.clone())),
           dependencies: vec![dep],
           resolve_options: None,
           options: context.compiler_options.clone(),

crates/rspack_core/src/compiler/module_executor/execute.rs

@@ -74,10 +74,11 @@ impl Task<MakeTaskContext> for ExecuteTask {
     let id = EXECUTE_MODULE_ID.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
 
     let mg = compilation.get_module_graph_mut();
-    let entry_module_identifier = mg
-      .get_module_by_dependency_id(&entry_dep_id)
-      .expect("should have module")
-      .identifier();
+    let Some(entry_module_identifier) = mg.get_module_by_dependency_id(&entry_dep_id) else {
+      return Err(rspack_error::error!("entry module not found"));
+    };
+
+    let entry_module_identifier = entry_module_identifier.identifier();
     let mut queue = vec![entry_module_identifier];
     let mut modules = IdentifierSet::default();
 

crates/rspack_core/src/compiler/module_executor/mod.rs

@@ -182,6 +182,7 @@ impl ModuleExecutor {
         let dep = LoaderImportDependency::new(
           request.clone(),
           original_module_context.unwrap_or(Context::from("")),
+          original_module_identifier,
         );
         let dep_id = *dep.id();
         v.insert(dep_id);

crates/rspack_core/src/dependency/loader_import.rs

@@ -1,21 +1,23 @@
 use super::AffectType;
 use crate::{
   AsContextDependency, AsDependencyTemplate, Context, Dependency, DependencyCategory, DependencyId,
-  DependencyType, ModuleDependency,
+  DependencyType, ModuleDependency, ModuleIdentifier,
 };
 
 #[derive(Debug, Hash, PartialEq, Eq, Clone)]
 pub struct LoaderImportDependency {
   id: DependencyId,
-  context: Context,
+  pub context: Context,
+  pub original_module: Option<ModuleIdentifier>,
   request: String,
 }
 
 impl LoaderImportDependency {
-  pub fn new(request: String, context: Context) -> Self {
+  pub fn new(request: String, context: Context, original_module: Option<ModuleIdentifier>) -> Self {
     Self {
       request,
       context,
+      original_module,
       id: DependencyId::new(),
     }
   }