feat: support module graph connection js api

crates/rspack_binding_values/src/lib.rs

@@ -18,6 +18,7 @@ mod html;
 mod identifier;
 mod module;
 mod module_graph;
+mod module_graph_connection;
 mod normal_module_factory;
 mod options;
 mod path_data;
@@ -47,6 +48,7 @@ pub use filename::*;
 pub use html::*;
 pub use module::*;
 pub use module_graph::*;
+pub use module_graph_connection::*;
 pub use normal_module_factory::*;
 pub use options::*;
 pub use path_data::*;

crates/rspack_binding_values/src/module_graph.rs

@@ -5,7 +5,9 @@
 use rspack_core::{Compilation, ModuleGraph, RuntimeSpec};
 use rustc_hash::FxHashSet;
 
-use crate::{JsDependency, JsExportsInfo, JsModule, JsModuleWrapper};
+use crate::{
+  JsDependency, JsExportsInfo, JsModule, JsModuleGraphConnectionWrapper, JsModuleWrapper,
+};
 
 #[napi]
 pub struct JsModuleGraph {
@@ -87,4 +89,35 @@
     let exports_info = module_graph.get_exports_info(&module.identifier);
     Ok(JsExportsInfo::new(exports_info, compilation))
   }
+
+  #[napi(ts_return_type = "JsModuleGraphConnection | null")]
+  pub fn get_connection(
+    &self,
+    dependency: &JsDependency,
+  ) -> napi::Result<Option<JsModuleGraphConnectionWrapper>> {
+    let (compilation, module_graph) = self.as_ref()?;
+    Ok(
+      module_graph
+        .connection_by_dependency_id(&dependency.dependency_id)
+        .map(|connection| {
+          JsModuleGraphConnectionWrapper::new(connection.dependency_id, &compilation)
+        }),
+    )
+  }
+
+  #[napi(ts_return_type = "JsModuleGraphConnection[]")]
+  pub fn get_outgoing_connections(
+    &self,
+    module: &JsModule,
+  ) -> napi::Result<Vec<JsModuleGraphConnectionWrapper>> {
+    let (compilation, module_graph) = self.as_ref()?;
+    Ok(
+      module_graph
+        .get_outgoing_connections(&module.identifier)
+        .map(|connection| {
+          JsModuleGraphConnectionWrapper::new(connection.dependency_id, &compilation)
+        })
+        .collect::<Vec<_>>(),
+    )
+  }
 }

crates/rspack_binding_values/src/module_graph_connection.rs

@@ -0,0 +1,125 @@
+use std::{cell::RefCell, ptr::NonNull};
+
+use napi::bindgen_prelude::ToNapiValue;
+use napi_derive::napi;
+use rspack_core::{Compilation, CompilationId, DependencyId, ModuleGraph};
+use rspack_napi::OneShotRef;
+use rustc_hash::FxHashMap as HashMap;
+
+use crate::{JsDependencyWrapper, JsModuleWrapper};
+
+#[napi]
+pub struct JsModuleGraphConnection {
+  compilation: NonNull<Compilation>,
+  dependency_id: DependencyId,
+}
+
+impl JsModuleGraphConnection {
+  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 JsModuleGraphConnection {
+  #[napi(getter, ts_return_type = "JsDependency")]
+  pub fn dependency(&self) -> napi::Result<JsDependencyWrapper> {
+    let (compilation, module_graph) = self.as_ref()?;
+    if let Some(dependency) = module_graph.dependency_by_id(&self.dependency_id) {
+      Ok(JsDependencyWrapper::new(
+        dependency.as_ref(),
+        compilation.id(),
+        Some(compilation),
+      ))
+    } else {
+      Err(napi::Error::from_reason(format!(
+        "Unable to access Dependency with id = {:#?} now. The Dependency have been removed on the Rust side.",
+        self.dependency_id
+      )))
+    }
+  }
+
+  #[napi(getter, ts_return_type = "JsModule | null")]
+  pub fn module(&self) -> napi::Result<Option<JsModuleWrapper>> {
+    let (compilation, module_graph) = self.as_ref()?;
+    if let Some(connection) = module_graph.connection_by_dependency_id(&self.dependency_id) {
+      let module = module_graph.module_by_identifier(connection.module_identifier());
+      Ok(module.map(|m| JsModuleWrapper::new(m.as_ref(), compilation.id(), Some(compilation))))
+    } else {
+      Err(napi::Error::from_reason(format!(
+        "Unable to access ModuleGraphConnection with id = {:#?} now. The ModuleGraphConnection have been removed on the Rust side.",
+        self.dependency_id
+      )))
+    }
+  }
+}
+
+type ModuleGraphConnectionRefs = HashMap<DependencyId, OneShotRef<JsModuleGraphConnection>>;
+
+type ModuleGraphConnectionRefsByCompilationId =
+  RefCell<HashMap<CompilationId, ModuleGraphConnectionRefs>>;
+
+thread_local! {
+  static MODULE_GRAPH_CONNECTION_INSTANCE_REFS: ModuleGraphConnectionRefsByCompilationId = Default::default();
+}
+
+pub struct JsModuleGraphConnectionWrapper {
+  compilation_id: CompilationId,
+  compilation: NonNull<Compilation>,
+  dependency_id: DependencyId,
+}
+
+impl JsModuleGraphConnectionWrapper {
+  pub fn new(dependency_id: DependencyId, compilation: &Compilation) -> Self {
+    #[allow(clippy::unwrap_used)]
+    Self {
+      dependency_id,
+      compilation_id: compilation.id(),
+      compilation: NonNull::new(compilation as *const Compilation as *mut Compilation).unwrap(),
+    }
+  }
+
+  pub fn cleanup_last_compilation(compilation_id: CompilationId) {
+    MODULE_GRAPH_CONNECTION_INSTANCE_REFS.with(|refs| {
+      let mut refs_by_compilation_id = refs.borrow_mut();
+      refs_by_compilation_id.remove(&compilation_id)
+    });
+  }
+}
+
+impl ToNapiValue for JsModuleGraphConnectionWrapper {
+  unsafe fn to_napi_value(
+    env: napi::sys::napi_env,
+    val: Self,
+  ) -> napi::Result<napi::sys::napi_value> {
+    MODULE_GRAPH_CONNECTION_INSTANCE_REFS.with(|refs| {
+      let mut refs_by_compilation_id = refs.borrow_mut();
+      let entry = refs_by_compilation_id.entry(val.compilation_id);
+      let refs = match entry {
+        std::collections::hash_map::Entry::Occupied(entry) => entry.into_mut(),
+        std::collections::hash_map::Entry::Vacant(entry) => {
+          let refs = HashMap::default();
+          entry.insert(refs)
+        }
+      };
+
+      match refs.entry(val.dependency_id) {
+        std::collections::hash_map::Entry::Occupied(occupied_entry) => {
+          let r = occupied_entry.get();
+          ToNapiValue::to_napi_value(env, r)
+        }
+        std::collections::hash_map::Entry::Vacant(vacant_entry) => {
+          let js_dependency = JsModuleGraphConnection {
+            compilation: val.compilation,
+            dependency_id: val.dependency_id,
+          };
+          let r = vacant_entry.insert(OneShotRef::new(env, js_dependency)?);
+          ToNapiValue::to_napi_value(env, r)
+        }
+      }
+    })
+  }
+}

packages/rspack-test-tools/tests/configCases/module-graph/get-outgoing-connections/index.js

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

packages/rspack-test-tools/tests/configCases/module-graph/get-outgoing-connections/rspack.config.js

@@ -0,0 +1,33 @@
+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 connection = compilation.moduleGraph.getConnection(entryDependency);
+                const outgoingConnection = compilation.moduleGraph.getOutgoingConnections(connection.module)[0];
+                expect(normalize(outgoingConnection.module.request)).toBe(normalize(join(__dirname, 'foo.js')));
+            });
+        });
+
+    }
+}
+
+/** @type {import("@rspack/core").Configuration} */
+module.exports = {
+    target: "web",
+    node: {
+        __dirname: false,
+        __filename: false,
+    },
+    plugins: [
+        new Plugin()
+    ]
+};

packages/rspack/etc/core.api.md

@@ -51,6 +51,7 @@ import { JsLibraryOptions } from '@rspack/binding';
 import { JsLoaderItem } from '@rspack/binding';
 import { JsModule } from '@rspack/binding';
 import type { JsModuleGraph } from '@rspack/binding';
+import { JsModuleGraphConnection } from '@rspack/binding';
 import { JsRuntimeModule } from '@rspack/binding';
 import type { JsStats } from '@rspack/binding';
 import type { JsStatsCompilation } from '@rspack/binding';
@@ -3761,11 +3762,27 @@ class ModuleGraph {
     // (undocumented)
     static __from_binding(binding: JsModuleGraph): ModuleGraph;
     // (undocumented)
+    getConnection(dependency: Dependency): ModuleGraphConnection | null;
+    // (undocumented)
     getExportsInfo(module: Module): ExportsInfo;
     // (undocumented)
     getIssuer(module: Module): Module | null;
     // (undocumented)
     getModule(dependency: Dependency): Module | null;
+    // (undocumented)
+    getOutgoingConnections(module: Module): ModuleGraphConnection[];
+}
+
+// @public (undocumented)
+class ModuleGraphConnection {
+    // (undocumented)
+    static __from_binding(binding: JsModuleGraphConnection): ModuleGraphConnection;
+    // (undocumented)
+    static __to_binding(data: ModuleGraphConnection): JsModuleGraphConnection;
+    // (undocumented)
+    readonly dependency: Dependency;
+    // (undocumented)
+    readonly module: Module | null;
 }
 
 // @public (undocumented)

packages/rspack/src/ModuleGraph.ts

@@ -2,6 +2,7 @@ import type { JsModuleGraph } from "@rspack/binding";
 import { Dependency } from "./Dependency";
 import { ExportsInfo } from "./ExportsInfo";
 import { Module } from "./Module";
+import { ModuleGraphConnection } from "./ModuleGraphConnection";
 
 export default class ModuleGraph {
 	static __from_binding(binding: JsModuleGraph) {
@@ -29,4 +30,17 @@ export default class ModuleGraph {
 			this.#inner.getExportsInfo(Module.__to_binding(module))
 		);
 	}
+
+	getConnection(dependency: Dependency): ModuleGraphConnection | null {
+		const binding = this.#inner.getConnection(
+			Dependency.__to_binding(dependency)
+		);
+		return binding ? ModuleGraphConnection.__from_binding(binding) : null;
+	}
+
+	getOutgoingConnections(module: Module): ModuleGraphConnection[] {
+		return this.#inner
+			.getOutgoingConnections(Module.__to_binding(module))
+			.map(binding => ModuleGraphConnection.__from_binding(binding));
+	}
 }

packages/rspack/src/ModuleGraphConnection.ts

@@ -0,0 +1,48 @@
+import type { JsModuleGraphConnection } from "@rspack/binding";
+import { Dependency } from "./Dependency";
+import { Module } from "./Module";
+
+const MODULE_GRAPH_CONNECTION_MAPPINGS = new WeakMap<
+	JsModuleGraphConnection,
+	ModuleGraphConnection
+>();
+
+export class ModuleGraphConnection {
+	declare readonly module: Module | null;
+	declare readonly dependency: Dependency;
+
+	#inner: JsModuleGraphConnection;
+
+	static __from_binding(binding: JsModuleGraphConnection) {
+		let connection = MODULE_GRAPH_CONNECTION_MAPPINGS.get(binding);
+		if (connection) {
+			return connection;
+		}
+		connection = new ModuleGraphConnection(binding);
+		MODULE_GRAPH_CONNECTION_MAPPINGS.set(binding, connection);
+		return connection;
+	}
+
+	static __to_binding(data: ModuleGraphConnection): JsModuleGraphConnection {
+		return data.#inner;
+	}
+
+	private constructor(binding: JsModuleGraphConnection) {
+		this.#inner = binding;
+
+		Object.defineProperties(this, {
+			module: {
+				enumerable: true,
+				get(): Module | null {
+					return binding.module ? Module.__from_binding(binding.module) : null;
+				}
+			},
+			dependency: {
+				enumerable: true,
+				get(): Dependency {
+					return Dependency.__from_binding(binding.dependency);
+				}
+			}
+		});
+	}
+}