feat: support contextModuleFactory beforeResolve hook

crates/node_binding/Cargo.toml

@@ -24,6 +24,7 @@ rspack_hook            = { path = "../rspack_hook" }
 rspack_identifier      = { path = "../rspack_identifier" }
 rspack_napi            = { path = "../rspack_napi" }
 rspack_tracing         = { path = "../rspack_tracing" }
+rspack_regex = { path = "../rspack_regex" }
 tokio                  = { workspace = true, features = ["rt", "rt-multi-thread"] }
 
 async-trait = { workspace = true }

crates/node_binding/binding.d.ts

@@ -294,6 +294,18 @@ export interface JsCompatSource {
   map?: Buffer
 }
 
+export interface JsContextModuleFactoryAfterResolveData {
+  resource: string
+  context: string
+  request: string
+  regExp?: string
+}
+
+export interface JsContextModuleFactoryBeforeResolveData {
+  context: string
+  request?: string
+}
+
 export interface JsCreateData {
   request: string
   userRequest: string
@@ -1415,8 +1427,8 @@ export interface RegisterJsTaps {
   registerNormalModuleFactoryResolveForSchemeTaps: (stages: Array<number>) => Array<{ function: ((arg: JsResolveForSchemeArgs) => Promise<[boolean | undefined, JsResolveForSchemeArgs]>); stage: number; }>
   registerNormalModuleFactoryAfterResolveTaps: (stages: Array<number>) => Array<{ function: ((arg: JsAfterResolveData) => Promise<[boolean | undefined, JsCreateData | undefined]>); stage: number; }>
   registerNormalModuleFactoryCreateModuleTaps: (stages: Array<number>) => Array<{ function: ((arg: JsNormalModuleFactoryCreateModuleArgs) => Promise<void>); stage: number; }>
-  registerContextModuleFactoryBeforeResolveTaps: (stages: Array<number>) => Array<{ function: ((arg: JsBeforeResolveArgs) => Promise<[boolean | undefined, JsBeforeResolveArgs]>); stage: number; }>
-  registerContextModuleFactoryAfterResolveTaps: (stages: Array<number>) => Array<{ function: ((arg: JsAfterResolveData) => Promise<boolean | undefined>); stage: number; }>
+  registerContextModuleFactoryBeforeResolveTaps: (stages: Array<number>) => Array<{ function: ((arg: false | JsContextModuleFactoryBeforeResolveData) => Promise<false | JsContextModuleFactoryBeforeResolveData>); stage: number; }>
+  registerContextModuleFactoryAfterResolveTaps: (stages: Array<number>) => Array<{ function: ((arg: false | JsContextModuleFactoryAfterResolveData) => Promise<false | JsContextModuleFactoryAfterResolveData>); stage: number; }>
 }
 
 /** Builtin loader runner */

crates/node_binding/src/plugins/interceptor.rs

@@ -11,12 +11,15 @@ use napi::{
 };
 use rspack_binding_values::{
   CompatSource, JsAfterResolveData, JsAfterResolveOutput, JsAssetEmittedArgs, JsBeforeResolveArgs,
-  JsBeforeResolveOutput, JsChunk, JsChunkAssetArgs, JsCompilation, JsCreateData,
+  JsBeforeResolveOutput, JsChunk, JsChunkAssetArgs, JsCompilation,
+  JsContextModuleFactoryAfterResolveData, JsContextModuleFactoryAfterResolveResult,
+  JsContextModuleFactoryBeforeResolveData, JsContextModuleFactoryBeforeResolveResult, JsCreateData,
   JsExecuteModuleArg, JsModule, JsNormalModuleFactoryCreateModuleArgs, JsResolveForSchemeArgs,
   JsResolveForSchemeOutput, JsRuntimeModule, JsRuntimeModuleArg, ToJsCompatSource, ToJsModule,
 };
 use rspack_core::{
-  rspack_sources::SourceExt, AssetEmittedInfo, BoxModule, Chunk, ChunkUkey, CodeGenerationResults,
+  rspack_sources::SourceExt, AfterResolveData, AfterResolveResult, AssetEmittedInfo,
+  BeforeResolveData, BeforeResolveResult, BoxModule, Chunk, ChunkUkey, CodeGenerationResults,
   Compilation, CompilationAfterOptimizeModules, CompilationAfterOptimizeModulesHook,
   CompilationAfterProcessAssets, CompilationAfterProcessAssetsHook, CompilationAfterSeal,
   CompilationAfterSealHook, CompilationBuildModule, CompilationBuildModuleHook,
@@ -42,6 +45,7 @@ use rspack_core::{
 use rspack_hook::{Hook, Interceptor};
 use rspack_identifier::IdentifierSet;
 use rspack_napi::threadsafe_function::ThreadsafeFunction;
+use rspack_regex::RspackRegex;
 
 #[napi(object)]
 pub struct JsTap {
@@ -434,15 +438,19 @@ pub struct RegisterJsTaps {
   pub register_normal_module_factory_create_module_taps:
     RegisterFunction<JsNormalModuleFactoryCreateModuleArgs, Promise<()>>,
   #[napi(
-    ts_type = "(stages: Array<number>) => Array<{ function: ((arg: JsBeforeResolveArgs) => Promise<[boolean | undefined, JsBeforeResolveArgs]>); stage: number; }>"
+    ts_type = "(stages: Array<number>) => Array<{ function: ((arg: false | JsContextModuleFactoryBeforeResolveData) => Promise<false | JsContextModuleFactoryBeforeResolveData>); stage: number; }>"
   )]
-  pub register_context_module_factory_before_resolve_taps:
-    RegisterFunction<JsBeforeResolveArgs, Promise<JsBeforeResolveOutput>>,
+  pub register_context_module_factory_before_resolve_taps: RegisterFunction<
+    JsContextModuleFactoryBeforeResolveResult,
+    Promise<JsContextModuleFactoryBeforeResolveResult>,
+  >,
   #[napi(
-    ts_type = "(stages: Array<number>) => Array<{ function: ((arg: JsAfterResolveData) => Promise<boolean | undefined>); stage: number; }>"
+    ts_type = "(stages: Array<number>) => Array<{ function: ((arg: false | JsContextModuleFactoryAfterResolveData) => Promise<false | JsContextModuleFactoryAfterResolveData>); stage: number; }>"
   )]
-  pub register_context_module_factory_after_resolve_taps:
-    RegisterFunction<JsAfterResolveData, Promise<Option<bool>>>,
+  pub register_context_module_factory_after_resolve_taps: RegisterFunction<
+    JsContextModuleFactoryAfterResolveResult,
+    Promise<JsContextModuleFactoryAfterResolveResult>,
+  >,
 }
 
 /* Compiler Hooks */
@@ -662,15 +670,15 @@ define_register!(
 /* ContextModuleFactory Hooks */
 define_register!(
   RegisterContextModuleFactoryBeforeResolveTaps,
-  tap = ContextModuleFactoryBeforeResolveTap<JsBeforeResolveArgs, Promise<JsBeforeResolveOutput>> @ ContextModuleFactoryBeforeResolveHook,
+  tap = ContextModuleFactoryBeforeResolveTap<JsContextModuleFactoryBeforeResolveResult, Promise<JsContextModuleFactoryBeforeResolveResult>> @ ContextModuleFactoryBeforeResolveHook,
   cache = true,
   sync = false,
   kind = RegisterJsTapKind::ContextModuleFactoryBeforeResolve,
   skip = true,
 );
 define_register!(
   RegisterContextModuleFactoryAfterResolveTaps,
-  tap = ContextModuleFactoryAfterResolveTap<JsAfterResolveData, Promise<Option<bool>>> @ ContextModuleFactoryAfterResolveHook,
+  tap = ContextModuleFactoryAfterResolveTap<JsContextModuleFactoryAfterResolveResult, Promise<JsContextModuleFactoryAfterResolveResult>> @ ContextModuleFactoryAfterResolveHook,
   cache = true,
   sync = false,
   kind = RegisterJsTapKind::ContextModuleFactoryAfterResolve,
@@ -1198,24 +1206,27 @@ impl NormalModuleFactoryCreateModule for NormalModuleFactoryCreateModuleTap {
 
 #[async_trait]
 impl ContextModuleFactoryBeforeResolve for ContextModuleFactoryBeforeResolveTap {
-  async fn run(&self, data: &mut ModuleFactoryCreateData) -> rspack_error::Result<Option<bool>> {
-    let dependency = data
-      .dependency
-      .as_context_dependency_mut()
-      .expect("should be context dependency");
-    match self
-      .function
-      .call_with_promise(JsBeforeResolveArgs {
-        request: dependency.request().to_string(),
-        context: data.context.to_string(),
-      })
-      .await
-    {
-      Ok((ret, resolve_data)) => {
-        dependency.set_request(resolve_data.request);
-        data.context = resolve_data.context.into();
-        Ok(ret)
+  async fn run(&self, result: BeforeResolveResult) -> rspack_error::Result<BeforeResolveResult> {
+    let js_result = match result {
+      BeforeResolveResult::Ignored => JsContextModuleFactoryBeforeResolveResult::A(false),
+      BeforeResolveResult::Data(d) => {
+        JsContextModuleFactoryBeforeResolveResult::B(JsContextModuleFactoryBeforeResolveData {
+          context: d.context,
+          request: d.request,
+        })
       }
+    };
+    match self.function.call_with_promise(js_result).await {
+      Ok(js_result) => match js_result {
+        napi::bindgen_prelude::Either::A(_) => Ok(BeforeResolveResult::Ignored),
+        napi::bindgen_prelude::Either::B(d) => {
+          let data = BeforeResolveData {
+            context: d.context,
+            request: d.request,
+          };
+          Ok(BeforeResolveResult::Data(Box::new(data)))
+        }
+      },
       Err(err) => Err(err),
     }
   }
@@ -1227,37 +1238,33 @@ impl ContextModuleFactoryBeforeResolve for ContextModuleFactoryBeforeResolveTap
 
 #[async_trait]
 impl ContextModuleFactoryAfterResolve for ContextModuleFactoryAfterResolveTap {
-  async fn run(&self, data: &mut ModuleFactoryCreateData) -> rspack_error::Result<Option<bool>> {
-    let dependency = data
-      .dependency
-      .as_context_dependency_mut()
-      .expect("should be context dependency");
-    self
-      .function
-      .call_with_promise(JsAfterResolveData {
-        request: dependency.request().to_string(),
-        context: data.context.to_string(),
-        file_dependencies: data
-          .file_dependencies
-          .clone()
-          .into_iter()
-          .map(|item| item.to_string_lossy().to_string())
-          .collect::<Vec<_>>(),
-        context_dependencies: data
-          .context_dependencies
-          .clone()
-          .into_iter()
-          .map(|item| item.to_string_lossy().to_string())
-          .collect::<Vec<_>>(),
-        missing_dependencies: data
-          .missing_dependencies
-          .clone()
-          .into_iter()
-          .map(|item| item.to_string_lossy().to_string())
-          .collect::<Vec<_>>(),
-        create_data: None,
-      })
-      .await
+  async fn run(&self, result: AfterResolveResult) -> rspack_error::Result<AfterResolveResult> {
+    let js_result = match result {
+      AfterResolveResult::Ignored => JsContextModuleFactoryAfterResolveResult::A(false),
+      AfterResolveResult::Data(d) => {
+        JsContextModuleFactoryAfterResolveResult::B(JsContextModuleFactoryAfterResolveData {
+          resource: d.resource.to_owned(),
+          context: d.context.to_owned(),
+          request: d.request.to_owned(),
+          reg_exp: d.reg_exp.clone().map(|r| r.to_string()),
+        })
+      }
+    };
+    match self.function.call_with_promise(js_result).await? {
+      napi::Either::A(_) => Ok(AfterResolveResult::Ignored),
+      napi::Either::B(d) => {
+        let data = AfterResolveData {
+          resource: d.resource,
+          context: d.context,
+          request: d.request,
+          reg_exp: match d.reg_exp {
+            Some(r) => Some(RspackRegex::new(&r)?),
+            None => None,
+          },
+        };
+        Ok(AfterResolveResult::Data(Box::new(data)))
+      }
+    }
   }
 
   fn stage(&self) -> i32 {

crates/rspack_binding_values/src/context_module_factory.rs

@@ -0,0 +1,22 @@
+use napi::bindgen_prelude::Either;
+use napi_derive::napi;
+
+#[napi(object)]
+pub struct JsContextModuleFactoryBeforeResolveData {
+  pub context: String,
+  pub request: Option<String>,
+}
+
+pub type JsContextModuleFactoryBeforeResolveResult =
+  Either<bool, JsContextModuleFactoryBeforeResolveData>;
+
+#[napi(object)]
+pub struct JsContextModuleFactoryAfterResolveData {
+  pub resource: String,
+  pub context: String,
+  pub request: String,
+  pub reg_exp: Option<String>,
+}
+
+pub type JsContextModuleFactoryAfterResolveResult =
+  Either<bool, JsContextModuleFactoryAfterResolveData>;

crates/rspack_binding_values/src/lib.rs

@@ -5,6 +5,7 @@ mod chunk_graph;
 mod chunk_group;
 mod codegen_result;
 mod compilation;
+mod context_module_factory;
 mod filename;
 mod module;
 mod normal_module_factory;
@@ -19,6 +20,7 @@ pub use chunk_graph::*;
 pub use chunk_group::*;
 pub use codegen_result::*;
 pub use compilation::*;
+pub use context_module_factory::*;
 pub use filename::*;
 pub use module::*;
 pub use normal_module_factory::*;

crates/rspack_core/src/context_module.rs

@@ -151,7 +151,7 @@ pub struct ContextOptions {
   pub end: u32,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Clone)]
 pub struct ContextModuleOptions {
   pub addon: String,
   pub resource: String,