feat: allow rerouting ESM dependencies in succeedModule

Author: hardfist

crates/node_binding/napi-binding.d.ts

@@ -216,6 +216,7 @@ export declare class Dependency {
   get type(): string
   get category(): string
   get request(): string | undefined
+  set request(request: string)
   get attributes(): Record<string, string> | undefined
   get critical(): boolean
   set critical(val: boolean)

crates/rspack_binding_api/src/dependency.rs

@@ -1,11 +1,18 @@
-use std::{cell::RefCell, ptr::NonNull};
+use std::{
+  cell::RefCell,
+  ptr::NonNull,
+  sync::{
+    Arc,
+    atomic::{AtomicBool, Ordering},
+  },
+};
 
 use napi::{
   Either, Env,
   bindgen_prelude::{Array, Object, ToNapiValue},
 };
 use napi_derive::napi;
-use rspack_core::{Compilation, CompilationId, DependencyId, internal};
+use rspack_core::{BoxDependency, Compilation, CompilationId, DependencyId, internal};
 use rspack_napi::OneShotInstanceRef;
 use rspack_plugin_javascript::dependency::{
   CommonJsExportRequireDependency, ESMExportImportedSpecifierDependency,
@@ -22,6 +29,7 @@ pub struct Dependency {
   pub(crate) compilation_id: Option<CompilationId>,
   pub(crate) dependency_id: DependencyId,
   pub(crate) dependency: NonNull<dyn rspack_core::Dependency>,
+  mutable_access: Option<Arc<AtomicBool>>,
 }
 
 impl Dependency {
@@ -43,12 +51,41 @@ impl Dependency {
         }
       })
     } else {
+      if self
+        .mutable_access
+        .as_ref()
+        .is_some_and(|access| !access.load(Ordering::Acquire))
+      {
+        return Err(napi::Error::from_reason(
+          "Unable to access dependency outside the succeedModule hook callback",
+        ));
+      }
       // SAFETY:
       // We need to make users aware in the documentation that values obtained within the JS hook callback should not be used outside the scope of the callback.
       // We do not guarantee that the memory pointed to by the pointer remains valid when used outside the scope.
       f(unsafe { self.dependency.as_ref() }, None)
     }
   }
+
+  fn with_mut<R>(
+    &mut self,
+    f: impl FnOnce(&mut dyn rspack_core::Dependency) -> napi::Result<R>,
+  ) -> napi::Result<R> {
+    let Some(mutable_access) = &self.mutable_access else {
+      return Err(napi::Error::from_reason(
+        "Dependency.request can only be changed inside the succeedModule hook callback",
+      ));
+    };
+    if !mutable_access.load(Ordering::Acquire) {
+      return Err(napi::Error::from_reason(
+        "Dependency.request cannot be changed after the succeedModule hook callback",
+      ));
+    }
+
+    // SAFETY: The succeedModule hook exclusively borrows the pending dependencies until the
+    // JavaScript callback settles. `mutable_access` revokes this pointer before that borrow ends.
+    f(unsafe { self.dependency.as_mut() })
+  }
 }
 
 #[napi]
@@ -92,6 +129,25 @@ impl Dependency {
     })
   }
 
+  #[napi(setter)]
+  pub fn set_request(&mut self, request: String) -> napi::Result<()> {
+    self.with_mut(|dependency| {
+      if let Some(dependency) = dependency.downcast_mut::<ESMImportSpecifierDependency>() {
+        dependency.set_request(request.clone().into());
+        return Ok(());
+      }
+      if let Some(dependency) = dependency.downcast_mut::<ESMExportImportedSpecifierDependency>() {
+        dependency.set_request(request.into());
+        return Ok(());
+      }
+
+      Err(napi::Error::from_reason(format!(
+        "Dependency.request cannot be changed for dependency type '{}'",
+        dependency.dependency_type().as_str()
+      )))
+    })
+  }
+
   #[napi(getter, ts_return_type = "Record<string, string> | undefined")]
   pub fn attributes<'a>(&mut self, env: &'a Env) -> napi::Result<Either<Object<'a>, ()>> {
     self.with_ref(|dependency, _| {
@@ -164,7 +220,28 @@ impl Dependency {
             Either::B(())
           }
         }
-        None => Either::B(()),
+        None => {
+          if let Some(dependency) =
+            dependency.downcast_ref::<ESMExportImportedSpecifierDependency>()
+          {
+            let ids = dependency.ids();
+            let mut arr = env.create_array(ids.len() as u32)?;
+            for (i, v) in ids.iter().enumerate() {
+              arr.set(i as u32, v.as_str())?;
+            }
+            Either::A(arr)
+          } else if let Some(dependency) = dependency.downcast_ref::<ESMImportSpecifierDependency>()
+          {
+            let ids = dependency.ids();
+            let mut arr = env.create_array(ids.len() as u32)?;
+            for (i, v) in ids.iter().enumerate() {
+              arr.set(i as u32, v.as_str())?;
+            }
+            Either::A(arr)
+          } else {
+            Either::B(())
+          }
+        }
       })
     })
   }
@@ -189,6 +266,7 @@ pub struct DependencyWrapper {
   dependency: NonNull<dyn rspack_core::Dependency>,
   compilation_id: CompilationId,
   registered_compilation_id: Option<CompilationId>,
+  mutable_access: Option<Arc<AtomicBool>>,
 }
 
 impl DependencyWrapper {
@@ -220,6 +298,22 @@ impl DependencyWrapper {
       dependency,
       compilation_id,
       registered_compilation_id: compilation.map(Compilation::id),
+      mutable_access: None,
+    }
+  }
+
+  fn new_pending(
+    dependency_id: DependencyId,
+    dependency: NonNull<dyn rspack_core::Dependency>,
+    compilation_id: CompilationId,
+    mutable_access: Arc<AtomicBool>,
+  ) -> Self {
+    Self {
+      dependency_id,
+      dependency,
+      compilation_id,
+      registered_compilation_id: None,
+      mutable_access: Some(mutable_access),
     }
   }
 
@@ -254,6 +348,7 @@ impl ToNapiValue for DependencyWrapper {
             let instance = &mut **r;
             instance.compilation_id = val.registered_compilation_id;
             instance.dependency = val.dependency;
+            instance.mutable_access = val.mutable_access;
 
             ToNapiValue::to_napi_value(env, r)
           }
@@ -262,6 +357,7 @@ impl ToNapiValue for DependencyWrapper {
               compilation_id: val.registered_compilation_id,
               dependency_id: val.dependency_id,
               dependency: val.dependency,
+              mutable_access: val.mutable_access,
             };
             let r = vacant_entry.insert(OneShotInstanceRef::new(env, js_dependency)?);
             ToNapiValue::to_napi_value(env, r)
@@ -271,3 +367,80 @@ impl ToNapiValue for DependencyWrapper {
     }
   }
 }
+
+#[derive(Debug, Clone, Copy)]
+struct PendingDependency {
+  id: DependencyId,
+  dependency: NonNull<dyn rspack_core::Dependency>,
+}
+
+#[derive(Debug, Clone)]
+pub(crate) struct PendingDependencies {
+  dependencies: Vec<PendingDependency>,
+  compilation_id: CompilationId,
+  mutable_access: Arc<AtomicBool>,
+}
+
+pub(crate) struct PendingDependenciesGuard(Arc<AtomicBool>);
+
+impl Drop for PendingDependenciesGuard {
+  fn drop(&mut self) {
+    self.0.store(false, Ordering::Release);
+  }
+}
+
+// SAFETY: The succeedModule hook owns the pending dependency slice while the JavaScript callback
+// runs. The callback is awaited, and `mutable_access` is revoked before that borrow is released.
+unsafe impl Send for PendingDependencies {}
+unsafe impl Sync for PendingDependencies {}
+
+impl PendingDependencies {
+  pub(crate) fn new(dependencies: &mut [BoxDependency], compilation_id: CompilationId) -> Self {
+    let dependencies = dependencies
+      .iter_mut()
+      .map(|dependency| {
+        let id = *dependency.id();
+        let dependency = dependency.as_mut() as *mut dyn rspack_core::Dependency;
+        // SAFETY: The pointer is only exposed while the hook retains the source slice.
+        let dependency = unsafe {
+          std::mem::transmute::<
+            *mut (dyn rspack_core::Dependency + '_),
+            *mut (dyn rspack_core::Dependency + 'static),
+          >(dependency)
+        };
+        // SAFETY: `dependency` came from a valid mutable reference.
+        let dependency = unsafe { NonNull::new_unchecked(dependency) };
+        PendingDependency { id, dependency }
+      })
+      .collect();
+
+    Self {
+      dependencies,
+      compilation_id,
+      mutable_access: Arc::new(AtomicBool::new(true)),
+    }
+  }
+
+  pub(crate) fn is_active(&self) -> bool {
+    self.mutable_access.load(Ordering::Acquire)
+  }
+
+  pub(crate) fn guard(&self) -> PendingDependenciesGuard {
+    PendingDependenciesGuard(self.mutable_access.clone())
+  }
+
+  pub(crate) fn wrappers(&self) -> Vec<DependencyWrapper> {
+    self
+      .dependencies
+      .iter()
+      .map(|dependency| {
+        DependencyWrapper::new_pending(
+          dependency.id,
+          dependency.dependency,
+          self.compilation_id,
+          self.mutable_access.clone(),
+        )
+      })
+      .collect()
+  }
+}

crates/rspack_binding_api/src/module.rs

@@ -29,7 +29,7 @@ use crate::{
   codegen_result::JsCodegenerationResults,
   compiler_scoped_tsfn::CompilerScopedTsFnHandle,
   define_symbols,
-  dependency::DependencyWrapper,
+  dependency::{DependencyWrapper, PendingDependencies},
   modules::{ConcatenatedModule, ContextModule, ExternalModule, NormalModule},
   source::{JsSourceFromJs, JsSourceToJs},
 };
@@ -297,6 +297,7 @@ struct OriginalSourceNapiRef {
 pub struct Module {
   pub(crate) identifier: ModuleIdentifier,
   ptr: Option<NonNull<dyn rspack_core::Module>>,
+  pending_dependencies: Option<PendingDependencies>,
   compiler_id: CompilerId,
   original_source_ref: Option<OriginalSourceNapiRef>,
   pub(crate) build_info_ref: Option<WeakRef>,
@@ -496,6 +497,12 @@ impl Module {
 
   #[napi(getter, ts_return_type = "Dependency[]")]
   pub fn dependencies(&mut self) -> napi::Result<Vec<DependencyWrapper>> {
+    if let Some(pending_dependencies) = &self.pending_dependencies
+      && pending_dependencies.is_active()
+    {
+      return Ok(pending_dependencies.wrappers());
+    }
+
     self.with_ref(|compilation, module| {
       let Some(module_graph) = compilation.try_get_module_graph() else {
         return Err(napi::Error::from_reason(
@@ -624,6 +631,7 @@ pub struct ModuleObject {
   type_id: TypeId,
   identifier: ModuleIdentifier,
   ptr: Option<NonNull<dyn rspack_core::Module>>,
+  pending_dependencies: Option<PendingDependencies>,
   compiler_id: CompilerId,
 }
 
@@ -636,6 +644,7 @@ impl ModuleObject {
       type_id: module.as_any().type_id(),
       identifier: module.identifier(),
       ptr: None,
+      pending_dependencies: None,
       compiler_id,
     }
   }
@@ -647,6 +656,23 @@ impl ModuleObject {
       type_id: module.as_any().type_id(),
       identifier: module.identifier(),
       ptr: Some(module_ptr),
+      pending_dependencies: None,
+      compiler_id,
+    }
+  }
+
+  pub(crate) fn with_ptr_and_dependencies(
+    module_ptr: NonNull<dyn rspack_core::Module>,
+    compiler_id: CompilerId,
+    pending_dependencies: PendingDependencies,
+  ) -> Self {
+    let module = unsafe { module_ptr.as_ref() };
+
+    Self {
+      type_id: module.as_any().type_id(),
+      identifier: module.identifier(),
+      ptr: Some(module_ptr),
+      pending_dependencies: Some(pending_dependencies),
       compiler_id,
     }
   }
@@ -710,6 +736,7 @@ impl ToNapiValue for ModuleObject {
               Either5::E(module) => &mut **module,
             };
             instance.ptr = val.ptr;
+            instance.pending_dependencies = val.pending_dependencies;
             match instance_ref {
               Either5::A(r) => ToNapiValue::to_napi_value(env, r),
               Either5::B(r) => ToNapiValue::to_napi_value(env, r),
@@ -723,6 +750,7 @@ impl ToNapiValue for ModuleObject {
               identifier: val.identifier,
               compiler_id: val.compiler_id,
               ptr: val.ptr,
+              pending_dependencies: val.pending_dependencies,
               original_source_ref: None,
               build_info_ref: Default::default(),
             };
@@ -781,30 +809,35 @@ impl FromNapiValue for ModuleObject {
           type_id: TypeId::of::<rspack_core::NormalModule>(),
           identifier: normal_module.module.identifier,
           ptr: normal_module.module.ptr,
+          pending_dependencies: normal_module.module.pending_dependencies.clone(),
           compiler_id: normal_module.module.compiler_id,
         },
         Either5::B(concatenated_module) => Self {
           type_id: TypeId::of::<rspack_core::ConcatenatedModule>(),
           identifier: concatenated_module.module.identifier,
           ptr: concatenated_module.module.ptr,
+          pending_dependencies: concatenated_module.module.pending_dependencies.clone(),
           compiler_id: concatenated_module.module.compiler_id,
         },
         Either5::C(context_module) => Self {
           type_id: TypeId::of::<rspack_core::ContextModule>(),
           identifier: context_module.module.identifier,
           ptr: context_module.module.ptr,
+          pending_dependencies: context_module.module.pending_dependencies.clone(),
           compiler_id: context_module.module.compiler_id,
         },
         Either5::D(external_module) => Self {
           type_id: TypeId::of::<rspack_core::ExternalModule>(),
           identifier: external_module.module.identifier,
           ptr: external_module.module.ptr,
+          pending_dependencies: external_module.module.pending_dependencies.clone(),
           compiler_id: external_module.module.compiler_id,
         },
         Either5::E(module) => Self {
           type_id: TypeId::of::<dyn rspack_core::Module>(),
           identifier: module.identifier,
           ptr: module.ptr,
+          pending_dependencies: module.pending_dependencies.clone(),
           compiler_id: module.compiler_id,
         },
       })