feat: add buildModule hook

crates/node_binding/binding.d.ts

@@ -37,6 +37,12 @@ export class JsCompilation {
   addBuildDependencies(deps: Array<string>): void
 }
 
+export class JsModule {
+  resource: string
+  moduleIdentifier: string
+  identifier(): string
+}
+
 export class JsStats {
   getAssets(): JsStatsGetAssets
   getModules(reasons: boolean, moduleAssets: boolean, nestedModules: boolean): Array<JsStatsModule>
@@ -198,6 +204,7 @@ export interface JsHooks {
   afterCompile: (...args: any[]) => any
   finishModules: (...args: any[]) => any
   finishMake: (...args: any[]) => any
+  buildModule: (...args: any[]) => any
   beforeResolve: (...args: any[]) => any
   afterResolve: (...args: any[]) => any
   contextModuleBeforeResolve: (...args: any[]) => any
@@ -245,12 +252,6 @@ export interface JsLoaderResult {
   isPitching: boolean
 }
 
-export interface JsModule {
-  originalSource?: JsCompatSource
-  resource: string
-  moduleIdentifier: string
-}
-
 export interface JsResolveForSchemeInput {
   resourceData: JsResourceData
   scheme: string

crates/node_binding/src/hook.rs

@@ -5,6 +5,7 @@ use std::sync::{Arc, RwLock};
 pub enum Hook {
   Make,
   FinishMake,
+  BuildModule,
   Compilation,
   ThisCompilation,
   ProcessAssetsStageAdditional,
@@ -37,6 +38,7 @@ impl From<String> for Hook {
     match s.as_str() {
       "make" => Hook::Make,
       "finishMake" => Hook::FinishMake,
+      "buildModule" => Hook::BuildModule,
       "compilation" => Hook::Compilation,
       "thisCompilation" => Hook::ThisCompilation,
       "processAssetsStageAdditional" => Hook::ProcessAssetsStageAdditional,

crates/node_binding/src/js_values/hooks.rs

@@ -22,6 +22,7 @@ pub struct JsHooks {
   pub after_compile: JsFunction,
   pub finish_modules: JsFunction,
   pub finish_make: JsFunction,
+  pub build_module: JsFunction,
   pub before_resolve: JsFunction,
   pub after_resolve: JsFunction,
   pub context_module_before_resolve: JsFunction,

crates/node_binding/src/js_values/module.rs

@@ -2,29 +2,29 @@ use napi::bindgen_prelude::*;
 use rspack_core::Module;
 use rspack_identifier::Identifiable;
 
-use super::{JsCompatSource, ToJsCompatSource};
-
-#[napi(object)]
+#[napi]
 pub struct JsModule {
-  pub original_source: Option<JsCompatSource>,
   pub resource: String,
   pub module_identifier: String,
 }
 
+#[napi]
+impl JsModule {
+  #[napi]
+  pub fn identifier(&self) -> String {
+    self.module_identifier.to_string()
+  }
+}
+
 pub trait ToJsModule {
   fn to_js_module(&self) -> Result<JsModule>;
 }
 
 impl ToJsModule for dyn Module + '_ {
   fn to_js_module(&self) -> Result<JsModule> {
-    let original_source = self
-      .original_source()
-      .and_then(|source| source.to_js_compat_source().ok());
     self
       .try_as_normal_module()
       .map(|normal_module| JsModule {
-        original_source,
-
         resource: normal_module
           .resource_resolved_data()
           .resource_path

crates/node_binding/src/plugins/mod.rs

@@ -43,6 +43,7 @@ pub struct JsHooksAdapter {
   pub after_compile_tsfn: ThreadsafeFunction<JsCompilation, ()>,
   pub finish_modules_tsfn: ThreadsafeFunction<JsCompilation, ()>,
   pub finish_make_tsfn: ThreadsafeFunction<JsCompilation, ()>,
+  pub build_module_tsfn: ThreadsafeFunction<JsModule, ()>, // TODO
   pub chunk_asset_tsfn: ThreadsafeFunction<JsChunkAssetArgs, ()>,
   pub before_resolve: ThreadsafeFunction<BeforeResolveData, (Option<bool>, BeforeResolveData)>,
   pub after_resolve: ThreadsafeFunction<AfterResolveData, Option<bool>>,
@@ -464,6 +465,22 @@ impl rspack_core::Plugin for JsHooksAdapter {
       .map_err(|err| internal_error!("Failed to call finish make: {err}"))?
   }
 
+  async fn build_module(&self, module: &mut dyn rspack_core::Module) -> rspack_error::Result<()> {
+    if self.is_hook_disabled(&Hook::BuildModule) {
+      return Ok(());
+    }
+
+    self
+      .build_module_tsfn
+      .call(
+        module.to_js_module().expect("Convert to js_module failed."),
+        ThreadsafeFunctionCallMode::NonBlocking,
+      )
+      .into_rspack_result()?
+      .await
+      .map_err(|err| internal_error!("Failed to call build module: {err}"))?
+  }
+
   async fn finish_modules(
     &mut self,
     compilation: &mut rspack_core::Compilation,
@@ -586,6 +603,7 @@ impl JsHooksAdapter {
       after_compile,
       finish_modules,
       finish_make,
+      build_module,
       chunk_asset,
       succeed_module,
       still_valid_module,
@@ -626,6 +644,8 @@ impl JsHooksAdapter {
       js_fn_into_theadsafe_fn!(after_compile, env);
     let finish_make_tsfn: ThreadsafeFunction<JsCompilation, ()> =
       js_fn_into_theadsafe_fn!(finish_make, env);
+    let build_module_tsfn: ThreadsafeFunction<JsModule, ()> =
+      js_fn_into_theadsafe_fn!(build_module, env);
     let finish_modules_tsfn: ThreadsafeFunction<JsCompilation, ()> =
       js_fn_into_theadsafe_fn!(finish_modules, env);
     let context_module_before_resolve: ThreadsafeFunction<BeforeResolveData, Option<bool>> =
@@ -670,6 +690,7 @@ impl JsHooksAdapter {
       normal_module_factory_resolve_for_scheme,
       finish_modules_tsfn,
       finish_make_tsfn,
+      build_module_tsfn,
       chunk_asset_tsfn,
       after_resolve,
       succeed_module_tsfn,

crates/rspack_core/src/plugin/plugin_driver.rs

@@ -539,6 +539,7 @@ impl PluginDriver {
     Ok(())
   }
 
+  #[instrument(name = "plugin:build_module", skip_all)]
   pub async fn build_module(&self, module: &mut dyn Module) -> Result<()> {
     for plugin in &self.plugins {
       plugin.build_module(module).await?;

packages/rspack/src/compilation.ts

@@ -90,6 +90,7 @@ export class Compilation {
 		processWarnings: tapable.SyncWaterfallHook<[Error[]]>;
 		succeedModule: tapable.SyncHook<[JsModule], undefined>;
 		stillValidModule: tapable.SyncHook<[JsModule], undefined>;
+		buildModule: tapable.SyncHook<[JsModule]>;
 	};
 	options: RspackOptionsNormalized;
 	outputOptions: OutputNormalized;
@@ -125,7 +126,8 @@ export class Compilation {
 			chunkAsset: new tapable.SyncHook(["chunk", "filename"]),
 			processWarnings: new tapable.SyncWaterfallHook(["warnings"]),
 			succeedModule: new tapable.SyncHook(["module"]),
-			stillValidModule: new tapable.SyncHook(["module"])
+			stillValidModule: new tapable.SyncHook(["module"]),
+			buildModule: new tapable.SyncHook(["module"])
 		};
 		this.compiler = compiler;
 		this.resolverFactory = compiler.resolverFactory;
@@ -618,7 +620,6 @@ export class Compilation {
 	get modules() {
 		return this.getModules().map(item => {
 			return {
-				identifier: () => item.moduleIdentifier,
 				...item
 			};
 		});

packages/rspack/src/compiler.ts

@@ -343,7 +343,8 @@ class Compiler {
 					contextModuleBeforeResolve:
 						this.#contextModuleBeforeResolve.bind(this),
 					succeedModule: this.#succeedModule.bind(this),
-					stillValidModule: this.#stillValidModule.bind(this)
+					stillValidModule: this.#stillValidModule.bind(this),
+					buildModule: this.#buildModule.bind(this)
 				},
 				createThreadsafeNodeFSFromRaw(this.outputFileSystem),
 				loaderContext => runLoader(loaderContext, this)
@@ -606,7 +607,8 @@ class Compiler {
 			beforeResolve: this.compilation.normalModuleFactory?.hooks.beforeResolve,
 			afterResolve: this.compilation.normalModuleFactory?.hooks.afterResolve,
 			succeedModule: this.compilation.hooks.succeedModule,
-			stillValidModule: this.compilation.hooks.stillValidModule
+			stillValidModule: this.compilation.hooks.stillValidModule,
+			buildModule: this.compilation.hooks.buildModule
 		};
 		for (const [name, hook] of Object.entries(hookMap)) {
 			if (hook?.taps.length === 0) {
@@ -637,6 +639,11 @@ class Compiler {
 		this.#updateDisabledHooks();
 	}
 
+	async #buildModule(module: binding.JsModule) {
+		this.compilation.hooks.buildModule.call(module);
+		this.#updateDisabledHooks();
+	}
+
 	async #processAssets(stage: number) {
 		await this.compilation
 			.__internal_getProcessAssetsHookByStage(stage)

packages/rspack/tests/configCases/hooks/build-module/a.js

@@ -0,0 +1 @@
+export const a = 3;

packages/rspack/tests/configCases/hooks/build-module/index.js

@@ -0,0 +1,5 @@
+import { a } from "./a.js";
+
+it("should compile successfully with build-module", () => {
+	expect(a).toBe(3);
+});

packages/rspack/tests/configCases/hooks/build-module/webpack.config.js

@@ -0,0 +1,23 @@
+const { strict } = require("assert");
+const pluginName = "plugin";
+
+class Plugin {
+	apply(compiler) {
+		let identifiers = [];
+		compiler.hooks.compilation.tap(pluginName, compilation => {
+			compilation.hooks.buildModule.tap(pluginName, m => {
+				identifiers.push(m.identifier());
+			});
+		});
+		compiler.hooks.done.tap(pluginName, () => {
+			strict(identifiers.some(i => i.endsWith("index.js")));
+			strict(identifiers.some(i => i.endsWith("a.js")));
+		});
+	}
+}
+
+/**@type {import('@rspack/cli').Configuration}*/
+module.exports = {
+	context: __dirname,
+	plugins: [new Plugin()]
+};