feat: js module graph api (#8470)

crates/node_binding/binding.d.ts

@@ -95,6 +95,7 @@ export declare class JsCompilation {
   importModule(request: string, layer: string | undefined | null, publicPath: JsFilename | undefined | null, baseUri: string | undefined | null, originalModule: string | undefined | null, originalModuleContext: string | undefined | null, callback: any): void
   get entries(): JsEntries
   addRuntimeModule(chunkUkey: number, runtimeModule: JsAddingRuntimeModule): void
+  get moduleGraph(): JsModuleGraph
 }
 
 export declare class JsContextModuleFactoryAfterResolveData {
@@ -181,6 +182,12 @@ export declare class JsModule {
   get useSourceMap(): boolean
 }
 
+export declare class JsModuleGraph {
+  getModule(jsDependency: JsDependency): JsModule | null
+  getUsedExports(jsModule: JsModule, jsRuntime: string | Array<string>): boolean | Array<string> | null
+  getIssuer(module: JsModule): JsModule | null
+}
+
 export declare class JsResolver {
   resolveSync(path: string, request: string): string | false
   withOptions(raw?: RawResolveOptionsWithDependencyType | undefined | null): JsResolver

crates/rspack_binding_values/src/compilation/mod.rs

@@ -25,6 +25,7 @@ use rspack_plugin_runtime::RuntimeModuleFromJs;
 use super::{JsFilename, PathWithInfo};
 use crate::utils::callbackify;
 use crate::JsAddingRuntimeModule;
+use crate::JsModuleGraph;
 use crate::JsModuleWrapper;
 use crate::JsStatsOptimizationBailout;
 use crate::LocalJsFilename;
@@ -694,6 +695,12 @@ impl JsCompilation {
       )
       .map_err(|e| Error::new(napi::Status::GenericFailure, format!("{e}")))
   }
+
+  #[napi(getter)]
+  pub fn module_graph(&self) -> napi::Result<JsModuleGraph> {
+    let compilation = self.as_ref()?;
+    Ok(JsModuleGraph::new(compilation))
+  }
 }
 
 thread_local! {

crates/rspack_binding_values/src/lib.rs

@@ -13,6 +13,7 @@ mod filename;
 mod html;
 mod identifier;
 mod module;
+mod module_graph;
 mod normal_module_factory;
 mod options;
 mod path_data;
@@ -37,6 +38,7 @@ pub use dependency_block::*;
 pub use filename::*;
 pub use html::*;
 pub use module::*;
+pub use module_graph::*;
 pub use normal_module_factory::*;
 pub use options::*;
 pub use path_data::*;

crates/rspack_binding_values/src/module.rs

@@ -22,7 +22,7 @@ pub struct JsFactoryMeta {
 
 #[napi]
 pub struct JsModule {
-  identifier: ModuleIdentifier,
+  pub(crate) identifier: ModuleIdentifier,
   module: NonNull<dyn Module>,
   compilation_id: CompilationId,
   compilation: Option<NonNull<Compilation>>,

crates/rspack_binding_values/src/module_graph.rs

@@ -0,0 +1,83 @@
+use std::{ptr::NonNull, sync::Arc};
+
+use napi::{Either, Env, JsString};
+use napi_derive::napi;
+use rspack_core::{Compilation, ModuleGraph, RuntimeSpec};
+use rustc_hash::FxHashSet;
+
+use crate::{JsDependency, JsModule, JsModuleWrapper};
+
+#[napi]
+pub struct JsModuleGraph {
+  compilation: NonNull<Compilation>,
+}
+
+impl JsModuleGraph {
+  pub fn new(compilation: &Compilation) -> Self {
+    #[allow(clippy::unwrap_used)]
+    JsModuleGraph {
+      compilation: NonNull::new(compilation as *const Compilation as *mut Compilation).unwrap(),
+    }
+  }
+
+  fn as_ref(&self) -> napi::Result<(&'static Compilation, ModuleGraph<'static>)> {
+    let compilation = unsafe { self.compilation.as_ref() };
+    let module_graph = compilation.get_module_graph();
+
+    Ok((compilation, module_graph))
+  }
+}
+
+#[napi]
+impl JsModuleGraph {
+  #[napi(ts_return_type = "JsModule | null")]
+  pub fn get_module(&self, js_dependency: &JsDependency) -> napi::Result<Option<JsModuleWrapper>> {
+    let (compilation, module_graph) = self.as_ref()?;
+    let module = module_graph.get_module_by_dependency_id(&js_dependency.dependency_id);
+    let js_module = module
+      .map(|module| JsModuleWrapper::new(module.as_ref(), compilation.id(), Some(compilation)));
+    Ok(js_module)
+  }
+
+  #[napi]
+  pub fn get_used_exports(
+    &self,
+    env: Env,
+    js_module: &JsModule,
+    js_runtime: Either<String, Vec<String>>,
+  ) -> napi::Result<Option<Either<bool, Vec<JsString>>>> {
+    let (_, module_graph) = self.as_ref()?;
+
+    let mut runtime: FxHashSet<Arc<str>> = FxHashSet::default();
+    match js_runtime {
+      Either::A(s) => {
+        runtime.insert(Arc::from(s));
+      }
+      Either::B(vec) => {
+        runtime.extend(vec.into_iter().map(Arc::from));
+      }
+    };
+    let used_exports =
+      module_graph.get_used_exports(&js_module.identifier, Some(&RuntimeSpec::new(runtime)));
+    Ok(match used_exports {
+      rspack_core::UsedExports::Null => None,
+      rspack_core::UsedExports::Bool(b) => Some(Either::A(b)),
+      rspack_core::UsedExports::Vec(vec) => Some(Either::B(
+        vec
+          .into_iter()
+          .map(|atom| env.create_string(atom.as_str()))
+          .collect::<napi::Result<Vec<_>>>()?,
+      )),
+    })
+  }
+
+  #[napi(ts_return_type = "JsModule | null")]
+  pub fn get_issuer(&self, module: &JsModule) -> napi::Result<Option<JsModuleWrapper>> {
+    let (compilation, module_graph) = self.as_ref()?;
+    let issuer = module_graph.get_issuer(&module.identifier);
+    Ok(
+      issuer
+        .map(|module| JsModuleWrapper::new(module.as_ref(), compilation.id(), Some(compilation))),
+    )
+  }
+}

packages/rspack-test-tools/tests/configCases/module_graph/get_issuer/index.js

@@ -0,0 +1 @@
+import './foo';

packages/rspack-test-tools/tests/configCases/module_graph/get_issuer/rspack.config.js

@@ -0,0 +1,32 @@
+const { normalize, join } = require('path');
+
+const PLUGIN_NAME = "Test";
+
+class Plugin {
+    /**
+     * @param {import("@rspack/core").Compiler} compiler
+     */
+    apply(compiler) {
+        compiler.hooks.compilation.tap(PLUGIN_NAME, compilation => {
+            compilation.hooks.finishModules.tap(PLUGIN_NAME, () => {
+                const fooModule = Array.from(compilation.modules.values())
+                    .find(module => normalize(module.request) === normalize(join(__dirname, 'foo.js')));
+                const issuer = compilation.moduleGraph.getIssuer(fooModule);
+                expect(normalize(issuer.request)).toBe(normalize(join(__dirname, 'index.js')));
+            });
+        });
+
+    }
+}
+
+/** @type {import("@rspack/core").Configuration} */
+module.exports = {
+    target: "web",
+    node: {
+        __dirname: false,
+        __filename: false,
+    },
+    plugins: [
+        new Plugin()
+    ]
+};

packages/rspack-test-tools/tests/configCases/module_graph/get_module/rspack.config.js

@@ -0,0 +1,32 @@
+const { normalize, join } = require('path');
+
+const PLUGIN_NAME = "Test";
+
+class Plugin {
+    /**
+     * @param {import("@rspack/core").Compiler} compiler
+     */
+    apply(compiler) {
+        compiler.hooks.compilation.tap(PLUGIN_NAME, compilation => {
+            compilation.hooks.finishModules.tap(PLUGIN_NAME, () => {
+                const entry = Array.from(compilation.entries.values())[0];
+                const entryDependency = entry.dependencies[0];
+                const refModule = compilation.moduleGraph.getModule(entryDependency);
+                expect(normalize(refModule.request)).toBe(normalize(join(__dirname, 'index.js')));
+            });
+        });
+
+    }
+}
+
+/** @type {import("@rspack/core").Configuration} */
+module.exports = {
+    target: "web",
+    node: {
+        __dirname: false,
+        __filename: false,
+    },
+    plugins: [
+        new Plugin()
+    ]
+};

packages/rspack/etc/core.api.md

@@ -48,6 +48,7 @@ import { JsHtmlPluginTag } from '@rspack/binding';
 import { JsLibraryOptions } from '@rspack/binding';
 import { JsLoaderItem } from '@rspack/binding';
 import { JsModule } from '@rspack/binding';
+import type { JsModuleGraph } from '@rspack/binding';
 import { JsRuntimeModule } from '@rspack/binding';
 import type { JsStats } from '@rspack/binding';
 import type { JsStatsCompilation } from '@rspack/binding';
@@ -713,6 +714,8 @@ export class Compilation {
         addAll: (deps: Iterable<string>) => void;
     };
     // (undocumented)
+    moduleGraph: ModuleGraph;
+    // (undocumented)
     get modules(): ReadonlySet<Module>;
     // (undocumented)
     name?: string;
@@ -1316,6 +1319,8 @@ class Dependency {
     // (undocumented)
     static __from_binding(binding: JsDependency): Dependency;
     // (undocumented)
+    static __to_binding(data: Dependency): JsDependency;
+    // (undocumented)
     readonly category: string;
     // (undocumented)
     critical: boolean;
@@ -1595,7 +1600,16 @@ interface Entry_2 {
 }
 
 // @public (undocumented)
-type EntryData = binding.JsEntryData;
+class EntryData {
+    // (undocumented)
+    static __from_binding(binding: binding.JsEntryData): EntryData;
+    // (undocumented)
+    dependencies: Dependency[];
+    // (undocumented)
+    includeDependencies: Dependency[];
+    // (undocumented)
+    options: binding.JsEntryOptions;
+}
 
 // @public
 export type EntryDependOn = string | string[];
@@ -3542,6 +3556,8 @@ export class Module {
     // (undocumented)
     static __from_binding(binding: JsModule, compilation?: Compilation): Module;
     // (undocumented)
+    static __to_binding(module: Module): JsModule;
+    // (undocumented)
     readonly blocks: DependenciesBlock[];
     readonly buildInfo: Record<string, any>;
     readonly buildMeta: Record<string, any>;
@@ -3642,6 +3658,16 @@ type ModuleFilterItemTypes = RegExp | string | ((name: string, module: any, type
 // @public (undocumented)
 type ModuleFilterTypes = boolean | ModuleFilterItemTypes | ModuleFilterItemTypes[];
 
+// @public (undocumented)
+class ModuleGraph {
+    // (undocumented)
+    static __from_binding(binding: JsModuleGraph): ModuleGraph;
+    // (undocumented)
+    getIssuer(module: Module): Module | null;
+    // (undocumented)
+    getModule(dependency: Dependency): Module | null;
+}
+
 // @public (undocumented)
 export type ModuleOptions = {
     defaultRules?: RuleSetRules;

packages/rspack/src/Compilation.ts

@@ -24,9 +24,11 @@ import { ChunkGraph } from "./ChunkGraph";
 import { ChunkGroup } from "./ChunkGroup";
 import type { Compiler } from "./Compiler";
 import type { ContextModuleFactory } from "./ContextModuleFactory";
+import { Dependency } from "./Dependency";
 import { Entrypoint } from "./Entrypoint";
 import { cutOffLoaderExecution } from "./ErrorHelpers";
 import { type CodeGenerationResult, Module } from "./Module";
+import ModuleGraph from "./ModuleGraph";
 import type { NormalModuleFactory } from "./NormalModuleFactory";
 import type { ResolverFactory } from "./ResolverFactory";
 import { JsRspackDiagnostic, type RspackError } from "./RspackError";
@@ -248,6 +250,7 @@ export class Compilation {
 	childrenCounters: Record<string, number>;
 	children: Compilation[];
 	chunkGraph: ChunkGraph;
+	moduleGraph: ModuleGraph;
 	fileSystemInfo = {
 		createSnapshot() {
 			// fake implement to support html-webpack-plugin
@@ -378,7 +381,9 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		this.logging = new Map();
 		this.childrenCounters = {};
 		this.children = [];
+
 		this.chunkGraph = new ChunkGraph(this);
+		this.moduleGraph = ModuleGraph.__from_binding(inner.moduleGraph);
 	}
 
 	get hash(): Readonly<string | null> {
@@ -1244,7 +1249,23 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	static PROCESS_ASSETS_STAGE_REPORT = 5000;
 }
 
-export type EntryData = binding.JsEntryData;
+export class EntryData {
+	dependencies: Dependency[];
+	includeDependencies: Dependency[];
+	options: binding.JsEntryOptions;
+
+	static __from_binding(binding: binding.JsEntryData): EntryData {
+		return new EntryData(binding);
+	}
+
+	private constructor(binding: binding.JsEntryData) {
+		this.dependencies = binding.dependencies.map(Dependency.__from_binding);
+		this.includeDependencies = binding.includeDependencies.map(
+			Dependency.__from_binding
+		);
+		this.options = binding.options;
+	}
+}
 
 export class Entries implements Map<string, EntryData> {
 	#data: binding.JsEntries;
@@ -1259,13 +1280,14 @@ export class Entries implements Map<string, EntryData> {
 
 	forEach(
 		callback: (
-			value: binding.JsEntryData,
+			value: EntryData,
 			key: string,
-			map: Map<string, binding.JsEntryData>
+			map: Map<string, EntryData>
 		) => void,
 		thisArg?: any
 	): void {
-		for (const [key, value] of this) {
+		for (const [key, binding] of this) {
+			const value = EntryData.__from_binding(binding);
 			callback.call(thisArg, value, key, this);
 		}
 	}
@@ -1281,7 +1303,7 @@ export class Entries implements Map<string, EntryData> {
 	}
 
 	values(): ReturnType<Map<string, EntryData>["values"]> {
-		return this.#data.values()[Symbol.iterator]();
+		return this.#data.values().map(EntryData.__from_binding)[Symbol.iterator]();
 	}
 
 	[Symbol.iterator](): ReturnType<Map<string, EntryData>["entries"]> {
@@ -1306,7 +1328,8 @@ export class Entries implements Map<string, EntryData> {
 	}
 
 	get(key: string): EntryData | undefined {
-		return this.#data.get(key);
+		const binding = this.#data.get(key);
+		return binding ? EntryData.__from_binding(binding) : undefined;
 	}
 
 	keys(): ReturnType<Map<string, EntryData>["keys"]> {