feat(plugin-driver): add execute module

crates/node_binding/binding.d.ts

@@ -236,6 +236,14 @@ export interface JsChunkGroup {
   name?: string
 }
 
+export interface JsCodegenerationResult {
+  sources: Record<string, string>
+}
+
+export interface JsCodegenerationResults {
+  map: Record<string, Record<string, JsCodegenerationResult>>
+}
+
 export interface JsCompatSource {
   /** Whether the underlying data structure is a `RawSource` */
   isRaw: boolean
@@ -245,6 +253,12 @@ export interface JsCompatSource {
   map?: Buffer
 }
 
+export interface JsExecuteModuleArg {
+  entry: string
+  runtimeModules: Array<string>
+  codegenResults: JsCodegenerationResults
+}
+
 export interface JsHooks {
   processAssetsStageAdditional: (...args: any[]) => any
   processAssetsStagePreProcess: (...args: any[]) => any
@@ -283,6 +297,7 @@ export interface JsHooks {
   chunkAsset: (...args: any[]) => any
   succeedModule: (...args: any[]) => any
   stillValidModule: (...args: any[]) => any
+  executeModule: (...args: any[]) => any
 }
 
 export interface JsLoaderContext {

crates/node_binding/src/hook.rs

@@ -40,6 +40,7 @@ pub enum Hook {
   BeforeResolve,
   SucceedModule,
   StillValidModule,
+  ExecuteModule,
 }
 
 impl From<String> for Hook {
@@ -81,6 +82,7 @@ impl From<String> for Hook {
       "beforeResolve" => Hook::BeforeResolve,
       "succeedModule" => Hook::SucceedModule,
       "stillValidModule" => Hook::StillValidModule,
+      "executeModule" => Hook::ExecuteModule,
       hook_name => panic!("{hook_name} is an invalid hook name"),
     }
   }

crates/node_binding/src/plugins/mod.rs

@@ -7,11 +7,11 @@ pub use loader::JsLoaderResolver;
 use napi::{Env, Result};
 use rspack_binding_macros::js_fn_into_threadsafe_fn;
 use rspack_binding_values::{
-  AfterResolveData, BeforeResolveData, JsAssetEmittedArgs, JsChunkAssetArgs, JsModule,
-  JsResolveForSchemeInput, JsResolveForSchemeResult, ToJsModule,
+  AfterResolveData, BeforeResolveData, JsAssetEmittedArgs, JsChunkAssetArgs, JsExecuteModuleArg,
+  JsModule, JsResolveForSchemeInput, JsResolveForSchemeResult, ToJsModule,
 };
 use rspack_core::{
-  ChunkAssetArgs, NormalModuleAfterResolveArgs, NormalModuleBeforeResolveArgs,
+  ChunkAssetArgs, ModuleIdentifier, NormalModuleAfterResolveArgs, NormalModuleBeforeResolveArgs,
   PluginNormalModuleFactoryAfterResolveOutput, PluginNormalModuleFactoryBeforeResolveOutput,
   PluginNormalModuleFactoryResolveForSchemeOutput, ResourceData,
 };
@@ -61,6 +61,7 @@ pub struct JsHooksAdapter {
     ThreadsafeFunction<JsResolveForSchemeInput, JsResolveForSchemeResult>,
   pub succeed_module_tsfn: ThreadsafeFunction<JsModule, ()>,
   pub still_valid_module_tsfn: ThreadsafeFunction<JsModule, ()>,
+  pub execute_module_tsfn: ThreadsafeFunction<JsExecuteModuleArg, Option<String>>,
 }
 
 impl Debug for JsHooksAdapter {
@@ -740,6 +741,34 @@ impl rspack_core::Plugin for JsHooksAdapter {
       .await
       .map_err(|err| internal_error!("Failed to call still_valid_module hook: {err}"))?
   }
+
+  fn execute_module(
+    &self,
+    entry: ModuleIdentifier,
+    runtime_modules: Vec<ModuleIdentifier>,
+    codegen_results: &rspack_core::CodeGenerationResults,
+  ) -> rspack_error::Result<Option<String>> {
+    if self.is_hook_disabled(&Hook::ExecuteModule) {
+      return Ok(None);
+    }
+
+    self
+      .execute_module_tsfn
+      .call(
+        JsExecuteModuleArg {
+          entry: entry.to_string(),
+          runtime_modules: runtime_modules
+            .into_iter()
+            .map(|id| id.to_string())
+            .collect(),
+          codegen_results: codegen_results.clone().into(),
+        },
+        ThreadsafeFunctionCallMode::NonBlocking,
+      )
+      .into_rspack_result()?
+      .blocking_recv()
+      .map_err(|recv_err| rspack_error::internal_error!(recv_err.to_string()))?
+  }
 }
 
 impl JsHooksAdapter {
@@ -782,6 +811,7 @@ impl JsHooksAdapter {
       chunk_asset,
       succeed_module,
       still_valid_module,
+      execute_module,
     } = js_hooks;
 
     let process_assets_stage_additional_tsfn: ThreadsafeFunction<(), ()> =
@@ -857,6 +887,8 @@ impl JsHooksAdapter {
       js_fn_into_threadsafe_fn!(succeed_module, env);
     let still_valid_module_tsfn: ThreadsafeFunction<JsModule, ()> =
       js_fn_into_threadsafe_fn!(still_valid_module, env);
+    let execute_module_tsfn: ThreadsafeFunction<JsExecuteModuleArg, Option<String>> =
+      js_fn_into_threadsafe_fn!(execute_module, env);
 
     Ok(JsHooksAdapter {
       disabled_hooks,
@@ -897,6 +929,7 @@ impl JsHooksAdapter {
       after_resolve,
       succeed_module_tsfn,
       still_valid_module_tsfn,
+      execute_module_tsfn,
     })
   }
 

crates/rspack_binding_values/src/codegen_result.rs

@@ -0,0 +1,60 @@
+use std::collections::HashMap;
+
+use napi_derive::napi;
+use rspack_core::{CodeGenerationResult, CodeGenerationResults};
+
+#[napi(object)]
+#[derive(Debug)]
+pub struct JsCodegenerationResults {
+  pub map: HashMap<String, HashMap<String, JsCodegenerationResult>>,
+}
+
+#[napi(object)]
+#[derive(Debug)]
+pub struct JsCodegenerationResult {
+  pub sources: HashMap<String, String>,
+}
+
+impl From<CodeGenerationResult> for JsCodegenerationResult {
+  fn from(result: CodeGenerationResult) -> Self {
+    Self {
+      sources: result
+        .inner
+        .into_iter()
+        .map(|(source_type, source)| (source_type.to_string(), source.source().to_string()))
+        .collect(),
+    }
+  }
+}
+
+impl From<CodeGenerationResults> for JsCodegenerationResults {
+  fn from(results: CodeGenerationResults) -> Self {
+    let id_result_map = results.module_generation_result_map;
+
+    Self {
+      map: results
+        .map
+        .into_iter()
+        .map(|(module_id, runtime_result_map)| {
+          (
+            module_id.to_string(),
+            runtime_result_map
+              .map
+              .into_iter()
+              .map(|(k, result_id)| {
+                (
+                  k,
+                  id_result_map
+                    .get(&result_id)
+                    .expect("should exist codegenResult")
+                    .clone()
+                    .into(),
+                )
+              })
+              .collect(),
+          )
+        })
+        .collect(),
+    }
+  }
+}

crates/rspack_binding_values/src/hooks.rs

@@ -40,4 +40,5 @@ pub struct JsHooks {
   pub chunk_asset: JsFunction,
   pub succeed_module: JsFunction,
   pub still_valid_module: JsFunction,
+  pub execute_module: JsFunction,
 }

crates/rspack_binding_values/src/lib.rs

@@ -2,6 +2,7 @@
 mod asset;
 mod chunk;
 mod chunk_group;
+mod codegen_result;
 mod compilation;
 mod hooks;
 mod module;
@@ -14,6 +15,7 @@ mod utils;
 pub use asset::*;
 pub use chunk::*;
 pub use chunk_group::*;
+pub use codegen_result::*;
 pub use compilation::*;
 pub use hooks::*;
 pub use module::*;

crates/rspack_binding_values/src/module.rs

@@ -3,6 +3,7 @@ use napi_derive::napi;
 use rspack_core::Module;
 
 use super::{JsCompatSource, ToJsCompatSource};
+use crate::JsCodegenerationResults;
 
 #[napi(object)]
 pub struct JsModule {
@@ -67,3 +68,10 @@ impl ToJsModule for dyn Module + '_ {
       .map_err(|_| napi::Error::from_reason("Failed to convert module to JsModule"))
   }
 }
+
+#[napi(object)]
+pub struct JsExecuteModuleArg {
+  pub entry: String,
+  pub runtime_modules: Vec<String>,
+  pub codegen_results: JsCodegenerationResults,
+}

crates/rspack_core/src/code_generation_results.rs

@@ -82,7 +82,7 @@ impl DerefMut for CodeGenerationData {
 
 #[derive(Debug, Default, Clone)]
 pub struct CodeGenerationResult {
-  inner: HashMap<SourceType, BoxSource>,
+  pub inner: HashMap<SourceType, BoxSource>,
   /// [definition in webpack](https://github.com/webpack/webpack/blob/4b4ca3bb53f36a5b8fc6bc1bd976ed7af161bd80/lib/Module.js#L75)
   pub data: CodeGenerationData,
   pub chunk_init_fragments: ChunkInitFragments,
@@ -147,10 +147,10 @@ impl Default for CodeGenResultId {
 
 pub static CODE_GEN_RESULT_ID: AtomicU32 = AtomicU32::new(0);
 
-#[derive(Debug, Default)]
+#[derive(Debug, Default, Clone)]
 pub struct CodeGenerationResults {
   pub module_generation_result_map: HashMap<CodeGenResultId, CodeGenerationResult>,
-  map: IdentifierMap<RuntimeSpecMap<CodeGenResultId>>,
+  pub map: IdentifierMap<RuntimeSpecMap<CodeGenResultId>>,
 }
 
 impl CodeGenerationResults {

crates/rspack_core/src/compiler/compilation.rs

@@ -1697,6 +1697,14 @@ impl Compilation {
   pub fn get_logger(&self, name: impl Into<String>) -> CompilationLogger {
     CompilationLogger::new(name.into(), self.logging.clone())
   }
+
+  pub fn execute_module(&self, entry: ModuleIdentifier) -> Result<Option<String>> {
+    let codegen_result = Default::default();
+    // TODO
+    self
+      .plugin_driver
+      .execute_module(entry, vec![], &codegen_result)
+  }
 }
 
 pub type CompilationAssets = HashMap<String, CompilationAsset>;

crates/rspack_core/src/plugin/api.rs

@@ -8,13 +8,13 @@ use rspack_sources::BoxSource;
 
 use crate::{
   AdditionalChunkRuntimeRequirementsArgs, AdditionalModuleRequirementsArgs, AssetEmittedArgs,
-  AssetInfo, BoxLoader, BoxModule, ChunkAssetArgs, ChunkHashArgs, Compilation, CompilationArgs,
-  CompilerOptions, ContentHashArgs, DoneArgs, FactorizeArgs, JsChunkHashArgs, MakeParam, Module,
-  ModuleFactoryResult, ModuleType, NormalModule, NormalModuleAfterResolveArgs,
-  NormalModuleBeforeResolveArgs, NormalModuleCreateData, NormalModuleFactoryContext,
-  OptimizeChunksArgs, ParserAndGenerator, PluginContext, ProcessAssetsArgs, RenderArgs,
-  RenderChunkArgs, RenderManifestArgs, RenderModuleContentArgs, RenderStartupArgs, Resolver,
-  SourceType, ThisCompilationArgs,
+  AssetInfo, BoxLoader, BoxModule, ChunkAssetArgs, ChunkHashArgs, CodeGenerationResults,
+  Compilation, CompilationArgs, CompilerOptions, ContentHashArgs, DoneArgs, FactorizeArgs,
+  JsChunkHashArgs, MakeParam, Module, ModuleFactoryResult, ModuleIdentifier, ModuleType,
+  NormalModule, NormalModuleAfterResolveArgs, NormalModuleBeforeResolveArgs,
+  NormalModuleCreateData, NormalModuleFactoryContext, OptimizeChunksArgs, ParserAndGenerator,
+  PluginContext, ProcessAssetsArgs, RenderArgs, RenderChunkArgs, RenderManifestArgs,
+  RenderModuleContentArgs, RenderStartupArgs, Resolver, SourceType, ThisCompilationArgs,
 };
 
 // use anyhow::{Context, Result};
@@ -465,6 +465,15 @@ pub trait Plugin: Debug + Send + Sync {
   fn seal(&self, _compilation: &mut Compilation) -> Result<()> {
     Ok(())
   }
+
+  fn execute_module(
+    &self,
+    _entry: ModuleIdentifier,
+    _runtime_modules: Vec<ModuleIdentifier>,
+    _codegen_results: &CodeGenerationResults,
+  ) -> Result<Option<String>> {
+    Ok(None)
+  }
 }
 
 pub type BoxPlugin = Box<dyn Plugin>;

crates/rspack_core/src/plugin/plugin_driver.rs

@@ -11,19 +11,20 @@ use tracing::instrument;
 use crate::{
   AdditionalChunkRuntimeRequirementsArgs, AdditionalModuleRequirementsArgs, ApplyContext,
   AssetEmittedArgs, BoxLoader, BoxedParserAndGeneratorBuilder, Chunk, ChunkAssetArgs,
-  ChunkContentHash, ChunkHashArgs, Compilation, CompilationArgs, CompilerOptions, Content,
-  ContentHashArgs, DoneArgs, FactorizeArgs, JsChunkHashArgs, MakeParam, Module, ModuleType,
-  NormalModule, NormalModuleAfterResolveArgs, NormalModuleBeforeResolveArgs,
-  NormalModuleCreateData, NormalModuleFactoryContext, OptimizeChunksArgs, Plugin,
-  PluginAdditionalChunkRuntimeRequirementsOutput, PluginAdditionalModuleRequirementsOutput,
-  PluginBuildEndHookOutput, PluginChunkHashHookOutput, PluginCompilationHookOutput, PluginContext,
-  PluginFactorizeHookOutput, PluginJsChunkHashHookOutput, PluginMakeHookOutput,
-  PluginModuleHookOutput, PluginNormalModuleFactoryAfterResolveOutput,
-  PluginNormalModuleFactoryBeforeResolveOutput, PluginProcessAssetsOutput,
-  PluginRenderChunkHookOutput, PluginRenderHookOutput, PluginRenderManifestHookOutput,
-  PluginRenderModuleContentOutput, PluginRenderStartupHookOutput, PluginThisCompilationHookOutput,
-  ProcessAssetsArgs, RenderArgs, RenderChunkArgs, RenderManifestArgs, RenderModuleContentArgs,
-  RenderStartupArgs, Resolver, ResolverFactory, Stats, ThisCompilationArgs,
+  ChunkContentHash, ChunkHashArgs, CodeGenerationResults, Compilation, CompilationArgs,
+  CompilerOptions, Content, ContentHashArgs, DoneArgs, FactorizeArgs, JsChunkHashArgs, MakeParam,
+  Module, ModuleIdentifier, ModuleType, NormalModule, NormalModuleAfterResolveArgs,
+  NormalModuleBeforeResolveArgs, NormalModuleCreateData, NormalModuleFactoryContext,
+  OptimizeChunksArgs, Plugin, PluginAdditionalChunkRuntimeRequirementsOutput,
+  PluginAdditionalModuleRequirementsOutput, PluginBuildEndHookOutput, PluginChunkHashHookOutput,
+  PluginCompilationHookOutput, PluginContext, PluginFactorizeHookOutput,
+  PluginJsChunkHashHookOutput, PluginMakeHookOutput, PluginModuleHookOutput,
+  PluginNormalModuleFactoryAfterResolveOutput, PluginNormalModuleFactoryBeforeResolveOutput,
+  PluginProcessAssetsOutput, PluginRenderChunkHookOutput, PluginRenderHookOutput,
+  PluginRenderManifestHookOutput, PluginRenderModuleContentOutput, PluginRenderStartupHookOutput,
+  PluginThisCompilationHookOutput, ProcessAssetsArgs, RenderArgs, RenderChunkArgs,
+  RenderManifestArgs, RenderModuleContentArgs, RenderStartupArgs, Resolver, ResolverFactory, Stats,
+  ThisCompilationArgs,
 };
 
 pub struct PluginDriver {
@@ -650,4 +651,22 @@ impl PluginDriver {
     }
     Ok(())
   }
+
+  #[instrument(name = "plugin:execute_module", skip_all)]
+  pub fn execute_module(
+    &self,
+    entry: ModuleIdentifier,
+    runtime_modules: Vec<ModuleIdentifier>,
+    codegen_results: &CodeGenerationResults,
+  ) -> Result<Option<String>> {
+    for plugin in &self.plugins {
+      if let Some(exports) =
+        plugin.execute_module(entry, runtime_modules.clone(), codegen_results)?
+      {
+        return Ok(Some(exports));
+      }
+    }
+
+    Ok(None)
+  }
 }

crates/rspack_testing/src/eval_raw.rs

@@ -33,3 +33,13 @@ JSON.stringify(raw, null, 2)
 "#
   )
 }
+
+pub fn evaluate_js(input: &str) -> String {
+  let r = Command::new("node")
+    .args(["-e", input])
+    .stdout(Stdio::piped())
+    .spawn()
+    .expect("ok");
+  let out = r.wait_with_output().expect("ok");
+  String::from_utf8(out.stdout).expect("failed to evaluate")
+}

crates/rspack_testing/src/lib.rs

@@ -2,7 +2,7 @@ mod eval_raw;
 mod loader;
 mod run_fixture;
 mod test_config;
-pub use eval_raw::evaluate_to_json;
+pub use eval_raw::{evaluate_js, evaluate_to_json};
 pub use run_fixture::{
   apply_from_fixture, test_fixture, test_fixture_css, test_fixture_css_modules, test_fixture_html,
   test_fixture_insta, test_fixture_js, test_rebuild_fixture,