feat: add assetPath hook

dmitry-stepanenko · dmitry-stepanenko · commit c9025c3a248c · 2023-06-09T17:13:01.000+03:00
diff --git a/crates/node_binding/binding.d.ts b/crates/node_binding/binding.d.ts
@@ -155,6 +155,12 @@ export interface JsAssetInfoRelated {
   sourceMap?: string
 }
 
+export interface JsAssetPathArgs {
+  filename: string
+  data: PathData
+  assetInfo?: JsAssetInfo
+}
+
 export interface JsChunk {
   files: Array<string>
 }
@@ -203,6 +209,7 @@ export interface JsHooks {
   contextModuleBeforeResolve: (...args: any[]) => any
   normalModuleFactoryResolveForScheme: (...args: any[]) => any
   chunkAsset: (...args: any[]) => any
+  assetPath: (...args: any[]) => any
   succeedModule: (...args: any[]) => any
   stillValidModule: (...args: any[]) => any
 }
diff --git a/crates/node_binding/src/hook.rs b/crates/node_binding/src/hook.rs
@@ -28,6 +28,7 @@ pub enum Hook {
   NormalModuleFactoryResolveForScheme,
   AfterResolve,
   BeforeResolve,
+  AssetPath,
   SucceedModule,
   StillValidModule,
 }
@@ -59,6 +60,7 @@ impl From<String> for Hook {
       "normalModuleFactoryResolveForScheme" => Hook::NormalModuleFactoryResolveForScheme,
       "afterResolve" => Hook::AfterResolve,
       "beforeResolve" => Hook::BeforeResolve,
+      "assetPath" => Hook::AssetPath,
       "succeedModule" => Hook::SucceedModule,
       "stillValidModule" => Hook::StillValidModule,
       hook_name => panic!("{hook_name} is an invalid hook name"),
diff --git a/crates/node_binding/src/js_values/asset.rs b/crates/node_binding/src/js_values/asset.rs
@@ -1,4 +1,4 @@
-use super::JsCompatSource;
+use super::{JsCompatSource, PathData};
 
 #[napi(object)]
 pub struct JsAssetInfoRelated {
@@ -102,3 +102,32 @@ impl From<&rspack_core::AssetEmittedArgs<'_>> for JsAssetEmittedArgs {
     }
   }
 }
+
+#[napi(object)]
+pub struct JsAssetPathArgs {
+  pub filename: String,
+  pub data: PathData,
+  pub asset_info: Option<JsAssetInfo>,
+}
+
+impl From<&rspack_core::AssetPathArgs<'_>> for JsAssetPathArgs {
+  fn from(args: &rspack_core::AssetPathArgs) -> Self {
+    let path_data = PathData {
+      filename: args.data.filename.map(|s| s.to_string()),
+      content_hash: args.data.content_hash.map(|s| s.to_string()),
+      hash: args.data.hash.map(|s| s.to_string()),
+      id: args.data.id.map(|s| s.to_string()),
+      runtime: args.data.runtime.map(|s| s.to_string()),
+      url: args.data.url.map(|s| s.to_string()),
+    };
+    let asset_info = args
+      .asset_info
+      .to_owned()
+      .map(|info| JsAssetInfo::from(info.to_owned()));
+    Self {
+      filename: args.filename.to_string(),
+      data: path_data,
+      asset_info,
+    }
+  }
+}
diff --git a/crates/node_binding/src/js_values/hooks.rs b/crates/node_binding/src/js_values/hooks.rs
@@ -27,6 +27,7 @@ pub struct JsHooks {
   pub context_module_before_resolve: JsFunction,
   pub normal_module_factory_resolve_for_scheme: JsFunction,
   pub chunk_asset: JsFunction,
+  pub asset_path: JsFunction,
   pub succeed_module: JsFunction,
   pub still_valid_module: JsFunction,
 }
diff --git a/crates/node_binding/src/plugins/mod.rs b/crates/node_binding/src/plugins/mod.rs
@@ -7,17 +7,18 @@ pub use loader::JsLoaderResolver;
 use napi::{Env, Result};
 use rspack_binding_macros::js_fn_into_theadsafe_fn;
 use rspack_core::{
-  ChunkAssetArgs, NormalModuleAfterResolveArgs, NormalModuleBeforeResolveArgs,
-  PluginNormalModuleFactoryAfterResolveOutput, PluginNormalModuleFactoryBeforeResolveOutput,
-  PluginNormalModuleFactoryResolveForSchemeOutput, ResourceData,
+  AssetPathArgs, ChunkAssetArgs, NormalModuleAfterResolveArgs, NormalModuleBeforeResolveArgs,
+  PluginJsAssetPathOutput, PluginNormalModuleFactoryAfterResolveOutput,
+  PluginNormalModuleFactoryBeforeResolveOutput, PluginNormalModuleFactoryResolveForSchemeOutput,
+  ResourceData,
 };
 use rspack_error::internal_error;
 use rspack_napi_shared::threadsafe_function::{ThreadsafeFunction, ThreadsafeFunctionCallMode};
 use rspack_napi_shared::NapiResultExt;
 
 use crate::js_values::{
-  AfterResolveData, BeforeResolveData, JsAssetEmittedArgs, JsChunkAssetArgs, JsModule,
-  JsResolveForSchemeInput, JsResolveForSchemeResult, ToJsModule,
+  AfterResolveData, BeforeResolveData, JsAssetEmittedArgs, JsAssetPathArgs, JsChunkAssetArgs,
+  JsModule, JsResolveForSchemeInput, JsResolveForSchemeResult, ToJsModule,
 };
 use crate::{DisabledHooks, Hook, JsCompilation, JsHooks};
 
@@ -45,6 +46,7 @@ pub struct JsHooksAdapter {
   pub finish_make_tsfn: ThreadsafeFunction<JsCompilation, ()>,
   pub chunk_asset_tsfn: ThreadsafeFunction<JsChunkAssetArgs, ()>,
   pub before_resolve: ThreadsafeFunction<BeforeResolveData, (Option<bool>, BeforeResolveData)>,
+  pub asset_path_tsfn: ThreadsafeFunction<JsAssetPathArgs, Option<String>>,
   pub after_resolve: ThreadsafeFunction<AfterResolveData, Option<bool>>,
   pub context_module_before_resolve: ThreadsafeFunction<BeforeResolveData, Option<bool>>,
   pub normal_module_factory_resolve_for_scheme:
@@ -125,6 +127,22 @@ impl rspack_core::Plugin for JsHooksAdapter {
       .map_err(|err| internal_error!("Failed to chunk asset: {err}"))?
   }
 
+  async fn asset_path(&self, args: &AssetPathArgs) -> PluginJsAssetPathOutput {
+    if self.is_hook_disabled(&Hook::AssetPath) {
+      return Ok(Some(args.filename.to_owned()));
+    }
+
+    self
+      .asset_path_tsfn
+      .call(
+        JsAssetPathArgs::from(args),
+        ThreadsafeFunctionCallMode::Blocking,
+      )
+      .into_rspack_result()?
+      .await
+      .map_err(|err| internal_error!("Failed to call this_asset_path: {err}"))?
+  }
+
   #[tracing::instrument(name = "js_hooks_adapter::make", skip_all)]
   async fn make(
     &self,
@@ -587,6 +605,7 @@ impl JsHooksAdapter {
       finish_modules,
       finish_make,
       chunk_asset,
+      asset_path,
       succeed_module,
       still_valid_module,
     } = js_hooks;
@@ -640,6 +659,8 @@ impl JsHooksAdapter {
     > = js_fn_into_theadsafe_fn!(normal_module_factory_resolve_for_scheme, env);
     let chunk_asset_tsfn: ThreadsafeFunction<JsChunkAssetArgs, ()> =
       js_fn_into_theadsafe_fn!(chunk_asset, env);
+    let asset_path_tsfn: ThreadsafeFunction<JsAssetPathArgs, Option<String>> =
+      js_fn_into_theadsafe_fn!(asset_path, env);
     let succeed_module_tsfn: ThreadsafeFunction<JsModule, ()> =
       js_fn_into_theadsafe_fn!(succeed_module, env);
     let still_valid_module_tsfn: ThreadsafeFunction<JsModule, ()> =
@@ -672,6 +693,7 @@ impl JsHooksAdapter {
       finish_make_tsfn,
       chunk_asset_tsfn,
       after_resolve,
+      asset_path_tsfn,
       succeed_module_tsfn,
       still_valid_module_tsfn,
     })
diff --git a/crates/rspack_core/src/compiler/compilation.rs b/crates/rspack_core/src/compiler/compilation.rs
@@ -1334,34 +1334,59 @@ impl Compilation {
     if data.hash.is_none() {
       data.hash = self.get_hash();
     }
-    filename.render(data, None)
+    self.get_asset_path(filename, data)
   }
 
   pub fn get_path_with_info<'b, 'a: 'b>(
     &'a self,
     filename: &Filename,
     mut data: PathData<'b>,
   ) -> (String, AssetInfo) {
-    let mut info = AssetInfo::default();
     if data.hash.is_none() {
       data.hash = self.get_hash();
     }
-    let path = filename.render(data, Some(&mut info));
-    (path, info)
+    self.get_asset_path_with_info(filename, data)
   }
 
-  pub fn get_asset_path(&self, filename: &Filename, data: PathData) -> String {
-    filename.render(data, None)
+  pub fn get_asset_path(&self, filename: &Filename, data: PathData<'_>) -> String {
+    tokio::task::block_in_place(move || {
+      tokio::runtime::Handle::current().block_on(async move {
+        let result = &self
+          .plugin_driver
+          .asset_path(filename.template().to_owned().to_string(), &data, None)
+          .await
+          .unwrap();
+        let new_file_name = Filename::from(result.to_owned());
+
+        new_file_name.render(data, None)
+      })
+    })
   }
 
   pub fn get_asset_path_with_info(
     &self,
     filename: &Filename,
     data: PathData,
   ) -> (String, AssetInfo) {
-    let mut info = AssetInfo::default();
-    let path = filename.render(data, Some(&mut info));
-    (path, info)
+    tokio::task::block_in_place(move || {
+      tokio::runtime::Handle::current().block_on(async move {
+        let mut info = AssetInfo::default();
+
+        let result = &self
+          .plugin_driver
+          .asset_path(
+            filename.template().to_owned().to_string(),
+            &data,
+            Some(&mut info),
+          )
+          .await
+          .unwrap();
+        let new_file_name = Filename::from(result.to_owned());
+
+        let path = new_file_name.render(data, Some(&mut info));
+        (path, info)
+      })
+    })
   }
 }
 
diff --git a/crates/rspack_core/src/plugin/api.rs b/crates/rspack_core/src/plugin/api.rs
@@ -7,13 +7,14 @@ use rspack_loader_runner::{Content, ResourceData};
 use rspack_sources::BoxSource;
 
 use crate::{
-  AdditionalChunkRuntimeRequirementsArgs, AssetEmittedArgs, AssetInfo, BoxLoader, BoxModule,
-  ChunkAssetArgs, ChunkHashArgs, Compilation, CompilationArgs, CompilerOptions, ContentHashArgs,
-  DoneArgs, FactorizeArgs, JsChunkHashArgs, Module, ModuleArgs, ModuleFactoryResult, ModuleType,
-  NormalModule, NormalModuleAfterResolveArgs, NormalModuleBeforeResolveArgs,
-  NormalModuleFactoryContext, OptimizeChunksArgs, ParserAndGenerator, PluginContext,
-  ProcessAssetsArgs, RenderArgs, RenderChunkArgs, RenderManifestArgs, RenderModuleContentArgs,
-  RenderStartupArgs, Resolver, SourceType, ThisCompilationArgs,
+  AdditionalChunkRuntimeRequirementsArgs, AssetEmittedArgs, AssetInfo, AssetPathArgs, BoxLoader,
+  BoxModule, ChunkAssetArgs, ChunkHashArgs, Compilation, CompilationArgs, CompilerOptions,
+  ContentHashArgs, DoneArgs, FactorizeArgs, JsChunkHashArgs, Module, ModuleArgs,
+  ModuleFactoryResult, ModuleType, NormalModule, NormalModuleAfterResolveArgs,
+  NormalModuleBeforeResolveArgs, NormalModuleFactoryContext, OptimizeChunksArgs,
+  ParserAndGenerator, PluginContext, ProcessAssetsArgs, RenderArgs, RenderChunkArgs,
+  RenderManifestArgs, RenderModuleContentArgs, RenderStartupArgs, Resolver, SourceType,
+  ThisCompilationArgs,
 };
 
 // use anyhow::{Context, Result};
@@ -39,6 +40,7 @@ pub type PluginRenderModuleContentOutput = Result<Option<BoxSource>>;
 pub type PluginRenderStartupHookOutput = Result<Option<BoxSource>>;
 pub type PluginRenderHookOutput = Result<Option<BoxSource>>;
 pub type PluginJsChunkHashHookOutput = Result<()>;
+pub type PluginJsAssetPathOutput = Result<Option<String>>;
 
 #[async_trait::async_trait]
 pub trait Plugin: Debug + Send + Sync {
@@ -165,6 +167,11 @@ pub trait Plugin: Debug + Send + Sync {
     Ok(())
   }
 
+  /// webpack `compilation.hooks.assetPath`
+  async fn asset_path(&self, _args: &AssetPathArgs) -> PluginJsAssetPathOutput {
+    Ok(Some(_args.filename.to_owned()))
+  }
+
   // JavascriptModulesPlugin hook
   fn render(&self, _ctx: PluginContext, _args: &RenderArgs) -> PluginRenderStartupHookOutput {
     Ok(None)
diff --git a/crates/rspack_core/src/plugin/args.rs b/crates/rspack_core/src/plugin/args.rs
@@ -9,8 +9,8 @@ use rustc_hash::FxHashSet as HashSet;
 use crate::ast::css::Ast as CssAst;
 use crate::ast::javascript::Ast as JsAst;
 use crate::{
-  Chunk, ChunkUkey, Compilation, Context, DependencyCategory, DependencyType, ErrorSpan,
-  ModuleDependency, ModuleIdentifier, Resolve, RuntimeGlobals, SharedPluginDriver, Stats,
+  AssetInfo, Chunk, ChunkUkey, Compilation, Context, DependencyCategory, DependencyType, ErrorSpan,
+  ModuleDependency, ModuleIdentifier, PathData, Resolve, RuntimeGlobals, SharedPluginDriver, Stats,
 };
 // #[derive(Debug)]
 // pub struct ParseModuleArgs<'a> {
@@ -212,6 +212,13 @@ pub struct ChunkAssetArgs<'a> {
   pub filename: &'a str,
 }
 
+#[derive(Debug)]
+pub struct AssetPathArgs<'a> {
+  pub filename: &'a str,
+  pub data: &'a PathData<'a>,
+  pub asset_info: Option<&'a AssetInfo>,
+}
+
 impl<'me> RenderChunkArgs<'me> {
   pub fn chunk(&self) -> &Chunk {
     self
diff --git a/crates/rspack_core/src/plugin/plugin_driver.rs b/crates/rspack_core/src/plugin/plugin_driver.rs
@@ -10,20 +10,20 @@ use rustc_hash::FxHashMap as HashMap;
 use tracing::instrument;
 
 use crate::{
-  AdditionalChunkRuntimeRequirementsArgs, ApplyContext, AssetEmittedArgs, BoxLoader,
-  BoxedParserAndGeneratorBuilder, Chunk, ChunkAssetArgs, ChunkContentHash, ChunkHashArgs,
-  Compilation, CompilationArgs, CompilerOptions, Content, ContentHashArgs, DoneArgs, FactorizeArgs,
-  JsChunkHashArgs, Module, ModuleArgs, ModuleType, NormalModule, NormalModuleAfterResolveArgs,
-  NormalModuleBeforeResolveArgs, NormalModuleFactoryContext, OptimizeChunksArgs, Plugin,
-  PluginAdditionalChunkRuntimeRequirementsOutput, 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,
+  AdditionalChunkRuntimeRequirementsArgs, ApplyContext, AssetEmittedArgs, AssetInfo, AssetPathArgs,
+  BoxLoader, BoxedParserAndGeneratorBuilder, Chunk, ChunkAssetArgs, ChunkContentHash,
+  ChunkHashArgs, Compilation, CompilationArgs, CompilerOptions, Content, ContentHashArgs, DoneArgs,
+  FactorizeArgs, JsChunkHashArgs, Module, ModuleArgs, ModuleType, NormalModule,
+  NormalModuleAfterResolveArgs, NormalModuleBeforeResolveArgs, NormalModuleFactoryContext,
+  OptimizeChunksArgs, PathData, Plugin, PluginAdditionalChunkRuntimeRequirementsOutput,
+  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 {
@@ -160,6 +160,31 @@ impl PluginDriver {
     Ok(())
   }
 
+  #[instrument(name = "plugin:asset_path", skip_all)]
+  pub async fn asset_path(
+    &self,
+    filename: String,
+    data: &PathData<'_>,
+    asset_info: Option<&AssetInfo>,
+  ) -> Result<String> {
+    let mut updated_name = filename;
+    for plugin in &self.plugins {
+      let temp = &plugin
+        .asset_path(&AssetPathArgs {
+          filename: &updated_name,
+          data: &data,
+          asset_info: asset_info,
+        })
+        .await?;
+
+      if let Some(value) = temp.to_owned() {
+        updated_name = value;
+      }
+    }
+
+    Ok(updated_name)
+  }
+
   pub async fn before_compile(
     &self,
     // compilationParams: &mut CompilationParams<'_>,
diff --git a/packages/rspack/src/compilation.ts b/packages/rspack/src/compilation.ts
@@ -88,6 +88,9 @@ export class Compilation {
 		finishModules: tapable.AsyncSeriesHook<[Iterable<JsModule>], undefined>;
 		chunkAsset: tapable.SyncHook<[JsChunk, string], undefined>;
 		processWarnings: tapable.SyncWaterfallHook<[Error[]]>;
+		assetPath: tapable.SyncWaterfallHook<
+			[path: string, options: PathData, assetInfo: AssetInfo | undefined]
+		>;
 		succeedModule: tapable.SyncHook<[JsModule], undefined>;
 		stillValidModule: tapable.SyncHook<[JsModule], undefined>;
 	};
@@ -124,6 +127,11 @@ export class Compilation {
 			finishModules: new tapable.AsyncSeriesHook(["modules"]),
 			chunkAsset: new tapable.SyncHook(["chunk", "filename"]),
 			processWarnings: new tapable.SyncWaterfallHook(["warnings"]),
+			assetPath: new tapable.SyncWaterfallHook([
+				"path",
+				"options",
+				"assetInfo"
+			]),
 			succeedModule: new tapable.SyncHook(["module"]),
 			stillValidModule: new tapable.SyncHook(["module"])
 		};
diff --git a/packages/rspack/src/compiler.ts b/packages/rspack/src/compiler.ts
diff --git a/packages/rspack/tests/configCases/hooks/asset-path/a.js b/packages/rspack/tests/configCases/hooks/asset-path/a.js
diff --git a/packages/rspack/tests/configCases/hooks/asset-path/b.js b/packages/rspack/tests/configCases/hooks/asset-path/b.js
diff --git a/packages/rspack/tests/configCases/hooks/asset-path/index.js b/packages/rspack/tests/configCases/hooks/asset-path/index.js
diff --git a/packages/rspack/tests/configCases/hooks/asset-path/webpack.config.js b/packages/rspack/tests/configCases/hooks/asset-path/webpack.config.js

Original file line number	Diff line number	Diff line change
`@@ -155,6 +155,12 @@ export interface JsAssetInfoRelated {`
`155`	`155`	`sourceMap?: string`
`156`	`156`	`}`
`157`	`157`
	`158`	`+export interface JsAssetPathArgs {`
	`159`	`+ filename: string`
	`160`	`+ data: PathData`
	`161`	`+ assetInfo?: JsAssetInfo`
	`162`	`+}`
	`163`	`+`
`158`	`164`	`export interface JsChunk {`
`159`	`165`	`files: Array<string>`
`160`	`166`	`}`
`@@ -203,6 +209,7 @@ export interface JsHooks {`
`203`	`209`	`contextModuleBeforeResolve: (...args: any[]) => any`
`204`	`210`	`normalModuleFactoryResolveForScheme: (...args: any[]) => any`
`205`	`211`	`chunkAsset: (...args: any[]) => any`
	`212`	`+ assetPath: (...args: any[]) => any`
`206`	`213`	`succeedModule: (...args: any[]) => any`
`207`	`214`	`stillValidModule: (...args: any[]) => any`
`208`	`215`	`}`
Original file line number	Diff line number	Diff line change
`@@ -27,6 +27,7 @@ pub struct JsHooks {`
`27`	`27`	`pub context_module_before_resolve: JsFunction,`
`28`	`28`	`pub normal_module_factory_resolve_for_scheme: JsFunction,`
`29`	`29`	`pub chunk_asset: JsFunction,`
	`30`	`+ pub asset_path: JsFunction,`
`30`	`31`	`pub succeed_module: JsFunction,`
`31`	`32`	`pub still_valid_module: JsFunction,`
`32`	`33`	`}`