fix: should not panic when SRI options is invalid (#12259)

Author: LingyuCoder

crates/rspack_binding_api/src/raw_options/raw_builtins/mod.rs

@@ -92,7 +92,7 @@ use rspack_plugin_runtime::{
 use rspack_plugin_runtime_chunk::RuntimeChunkPlugin;
 use rspack_plugin_schemes::{DataUriPlugin, FileUriPlugin};
 use rspack_plugin_size_limits::SizeLimitsPlugin;
-use rspack_plugin_sri::SubresourceIntegrityPlugin;
+use rspack_plugin_sri::{SubresourceIntegrityPlugin, SubresourceIntegrityPluginOptions};
 use rspack_plugin_swc_js_minimizer::SwcJsMinimizerRspackPlugin;
 use rspack_plugin_warn_sensitive_module::WarnCaseSensitiveModulesPlugin;
 use rspack_plugin_wasm::{
@@ -819,9 +819,15 @@ impl<'a> BuiltinPlugin<'a> {
       }
       BuiltinPluginName::SubresourceIntegrityPlugin => {
         let raw_options = downcast_into::<RawSubresourceIntegrityPluginOptions>(self.options)
-          .map_err(|report| napi::Error::from_reason(report.to_string()))?;
-        let options = raw_options.into();
-        plugins.push(SubresourceIntegrityPlugin::new(options).boxed());
+          .and_then(SubresourceIntegrityPluginOptions::try_from);
+        match raw_options {
+          Ok(options) => {
+            plugins.push(SubresourceIntegrityPlugin::new(options, None).boxed());
+          }
+          Err(error) => {
+            plugins.push(SubresourceIntegrityPlugin::new(Default::default(), Some(error)).boxed());
+          }
+        }
       }
       BuiltinPluginName::ModuleInfoHeaderPlugin => {
         let verbose = downcast_into::<bool>(self.options)

crates/rspack_binding_api/src/raw_options/raw_builtins/raw_sri.rs

@@ -22,9 +22,22 @@ pub struct RawSubresourceIntegrityPluginOptions {
   pub html_plugin: String,
 }
 
-impl From<RawSubresourceIntegrityPluginOptions> for SubresourceIntegrityPluginOptions {
-  fn from(options: RawSubresourceIntegrityPluginOptions) -> Self {
-    Self {
+impl TryFrom<RawSubresourceIntegrityPluginOptions> for SubresourceIntegrityPluginOptions {
+  type Error = rspack_error::Error;
+
+  fn try_from(options: RawSubresourceIntegrityPluginOptions) -> Result<Self, rspack_error::Error> {
+    let html_plugin = options.html_plugin.try_into()?;
+    if options.hash_func_names.is_empty() {
+      return Err(rspack_error::Error::error(
+        "Expect at least one SRI hash function name.".to_string(),
+      ));
+    }
+    let hash_func_names = options
+      .hash_func_names
+      .into_iter()
+      .map(SubresourceIntegrityHashFunction::try_from)
+      .collect::<Result<Vec<_>, rspack_error::Error>>()?;
+    Ok(Self {
       integrity_callback: if let Some(func) = options.integrity_callback {
         Some(Arc::new(move |data| {
           let func = func.clone();
@@ -33,13 +46,9 @@ impl From<RawSubresourceIntegrityPluginOptions> for SubresourceIntegrityPluginOp
       } else {
         None
       },
-      hash_func_names: options
-        .hash_func_names
-        .into_iter()
-        .map(SubresourceIntegrityHashFunction::from)
-        .collect::<Vec<_>>(),
-      html_plugin: options.html_plugin.into(),
-    }
+      hash_func_names,
+      html_plugin,
+    })
   }
 }
 

crates/rspack_plugin_sri/src/config.rs

@@ -15,25 +15,30 @@ use crate::integrity::SubresourceIntegrityHashFunction;
 pub type IntegrityCallbackFn =
   Arc<dyn Fn(IntegrityCallbackData) -> BoxFuture<'static, Result<()>> + Send + Sync>;
 
-#[derive(Debug)]
+#[derive(Debug, Default)]
 pub enum IntegrityHtmlPlugin {
   NativePlugin,
   JavaScriptPlugin,
+  #[default]
   Disabled,
 }
 
-impl From<String> for IntegrityHtmlPlugin {
-  fn from(value: String) -> Self {
+impl TryFrom<String> for IntegrityHtmlPlugin {
+  type Error = rspack_error::Error;
+
+  fn try_from(value: String) -> Result<Self, rspack_error::Error> {
     match value.as_str() {
-      "JavaScript" => Self::JavaScriptPlugin,
-      "Native" => Self::NativePlugin,
-      "Disabled" => Self::Disabled,
-      _ => panic!("Invalid integrity html plugin: {value}"),
+      "JavaScript" => Ok(Self::JavaScriptPlugin),
+      "Native" => Ok(Self::NativePlugin),
+      "Disabled" => Ok(Self::Disabled),
+      _ => Err(rspack_error::Error::error(format!(
+        "Invalid integrity html plugin: {value}"
+      ))),
     }
   }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Default)]
 pub struct SubresourceIntegrityPluginOptions {
   pub hash_func_names: Vec<SubresourceIntegrityHashFunction>,
   pub html_plugin: IntegrityHtmlPlugin,

crates/rspack_plugin_sri/src/integrity.rs

@@ -11,16 +11,17 @@ pub enum SubresourceIntegrityHashFunction {
   Sha512,
 }
 
-impl From<String> for SubresourceIntegrityHashFunction {
-  fn from(s: String) -> Self {
-    match s.as_str() {
-      "sha256" => Self::Sha256,
-      "sha384" => Self::Sha384,
-      "sha512" => Self::Sha512,
-      _ => panic!(
-        "sri hash function only support 'sha256', 'sha384' or 'sha512', but got '{}'.",
-        s
-      ),
+impl TryFrom<String> for SubresourceIntegrityHashFunction {
+  type Error = rspack_error::Error;
+
+  fn try_from(value: String) -> Result<Self, rspack_error::Error> {
+    match value.as_str() {
+      "sha256" => Ok(Self::Sha256),
+      "sha384" => Ok(Self::Sha384),
+      "sha512" => Ok(Self::Sha512),
+      _ => Err(rspack_error::Error::error(format!(
+        "Expect SRI hash function to be 'sha256', 'sha384' or 'sha512', but got '{value}'."
+      ))),
     }
   }
 }

crates/rspack_plugin_sri/src/lib.rs

@@ -44,11 +44,15 @@ static COMPILATION_CONTEXT_MAP: LazyLock<FxDashMap<CompilationId, Arc<SRICompila
 #[derive(Debug)]
 pub struct SubresourceIntegrityPlugin {
   pub options: SubresourceIntegrityPluginOptions,
+  pub validate_error: Option<rspack_error::Error>,
 }
 
 impl SubresourceIntegrityPlugin {
-  pub fn new(options: SubresourceIntegrityPluginOptions) -> Self {
-    Self::new_inner(options)
+  pub fn new(
+    options: SubresourceIntegrityPluginOptions,
+    validate_error: Option<rspack_error::Error>,
+  ) -> Self {
+    Self::new_inner(options, validate_error)
   }
 
   pub fn get_compilation_sri_context(id: CompilationId) -> Arc<SRICompilationContext> {
@@ -92,6 +96,23 @@ async fn warn_non_web(
   Ok(())
 }
 
+#[plugin_hook(CompilerThisCompilation for SubresourceIntegrityPlugin, stage = -10000)]
+async fn validate_error(
+  &self,
+  compilation: &mut Compilation,
+  _params: &mut CompilationParams,
+) -> Result<()> {
+  compilation.push_diagnostic(Diagnostic::error(
+    "SubresourceIntegrity".to_string(),
+    self
+      .validate_error
+      .as_ref()
+      .expect("should have validate error")
+      .to_string(),
+  ));
+  Ok(())
+}
+
 #[plugin_hook(CompilerThisCompilation for SubresourceIntegrityPlugin, stage = -10000)]
 async fn handle_compilation(
   &self,
@@ -156,6 +177,14 @@ impl Plugin for SubresourceIntegrityPlugin {
   }
 
   fn apply(&self, ctx: &mut rspack_core::ApplyContext<'_>) -> Result<()> {
+    if self.validate_error.is_some() {
+      ctx
+        .compiler_hooks
+        .this_compilation
+        .tap(validate_error::new(self));
+      return Ok(());
+    }
+
     if let ChunkLoading::Enable(chunk_loading) = &ctx.compiler_options.output.chunk_loading
       && matches!(
         chunk_loading,