fix(plugin_http): implement respond_with_url_module (#9800)

fix(plugin_http): implement respond_with_url_module

---------

Co-authored-by: ahabhgk <[email protected]>

Author: ScriptedAlchemy

crates/rspack_plugin_schemes/src/http_uri/http_cache.rs

@@ -137,7 +137,6 @@ impl HttpCache {
     if status == 304 {
       if let Some(cached) = cached_result {
         let new_valid_until = valid_until.max(cached.meta.valid_until);
-        println!("GET {} [{}] (unchanged)", url, status);
         return Ok(FetchResultType::Content(ContentFetchResult {
           meta: FetchResultMeta {
             fresh: true,
@@ -154,7 +153,6 @@ impl HttpCache {
     // Improved handling of redirects to match webpack
     if let Some(location) = location {
       if (301..=308).contains(&status) {
-        println!("GET {} [{}] -> {}", url, status, location);
         // Resolve relative redirects like webpack does
         let absolute_location = match Url::parse(&location) {
           Ok(loc) => loc.to_string(), // Already absolute
@@ -181,7 +179,6 @@ impl HttpCache {
               && cached_redirect.meta.store_cache == store_cache
               && cached_redirect.meta.etag == etag
             {
-              println!("GET {} [{}] (unchanged redirect)", url, status);
               return Ok(FetchResultType::Redirect(RedirectFetchResult {
                 meta: FetchResultMeta {
                   fresh: true,
@@ -215,14 +212,6 @@ impl HttpCache {
     }
 
     let content = response.body;
-    println!(
-      "GET {} [{}] {} kB{}",
-      url,
-      status,
-      content.len() / 1024,
-      if !store_lock { " no-cache" } else { "" }
-    );
-
     let integrity = compute_integrity(&content);
     let content_type = headers
       .get("content-type")
@@ -249,14 +238,6 @@ impl HttpCache {
       },
     };
 
-    if !store_cache {
-      println!(
-        "{} can't be stored in cache, due to Cache-Control header: {}",
-        url,
-        cache_control.unwrap_or_else(|| "null".to_string())
-      );
-    }
-
     if store_cache || store_lock {
       let should_update = cached_result
         .map(|cached| {
@@ -274,23 +255,7 @@ impl HttpCache {
         let lockfile = self.lockfile_cache.get_lockfile().await?;
         let mut lock_guard = lockfile.lock().await;
 
-        // Log entry updates similar to webpack
-        let old_entry = lock_guard.get_entry(url);
-        if let Some(old_entry) = old_entry {
-          if old_entry.integrity != entry.integrity {
-            println!("{} updated in lockfile: content changed", url);
-          } else if old_entry.content_type != entry.content_type {
-            println!(
-              "{} updated in lockfile: {} -> {}",
-              url, old_entry.content_type, entry.content_type
-            );
-          } else {
-            println!("{} updated in lockfile", url);
-          }
-        } else {
-          println!("{} added to lockfile", url);
-        }
-
+        // Update the lockfile entry
         lock_guard.entries_mut().insert(url.to_string(), entry);
         drop(lock_guard);
         self.lockfile_cache.save_lockfile().await?;
@@ -306,35 +271,26 @@ impl HttpCache {
       let lock_guard = lockfile.lock().await;
 
       if let Some(entry) = lock_guard.get_entry(resource) {
-        // Generate cache key using webpack-compatible format
         let cache_key = self.get_cache_key(&entry.resolved);
-
-        // Full path to the cache file
-        let cache_path_buf = PathBuf::from(cache_location).join(&cache_key);
+        let cache_path_buf = cache_location.join(&cache_key);
         let cache_path = Utf8Path::from_path(&cache_path_buf).expect("Invalid cache path");
 
-        // Try to read the file
-        match self.filesystem.read_file(cache_path).await {
-          Ok(content) => {
-            let meta = FetchResultMeta {
-              store_cache: true,
-              store_lock: true,
-              valid_until: entry.valid_until,
-              etag: entry.etag.clone(),
-              fresh: entry.valid_until >= current_time(),
-            };
-
-            let result = ContentFetchResult {
-              entry: entry.clone(),
-              content,
-              meta,
-            };
-
-            return Ok(Some(result));
-          }
-          Err(e) => {
-            println!("Failed to read cache file: {:?}", e);
-          }
+        if let Ok(content) = self.filesystem.read_file(cache_path).await {
+          let meta = FetchResultMeta {
+            store_cache: true,
+            store_lock: true,
+            valid_until: entry.valid_until,
+            etag: entry.etag.clone(),
+            fresh: entry.valid_until >= current_time(),
+          };
+
+          let result = ContentFetchResult {
+            entry: entry.clone(),
+            content,
+            meta,
+          };
+
+          return Ok(Some(result));
         }
       }
     }
@@ -343,8 +299,6 @@ impl HttpCache {
 
   async fn write_to_cache(&self, resource: &str, content: &[u8]) -> Result<()> {
     if let Some(cache_location) = &self.cache_location {
-      println!("Writing to cache at location: {:?}", cache_location);
-
       // Generate cache key using webpack-compatible format
       let cache_key = self.get_cache_key(resource);
 
@@ -355,22 +309,12 @@ impl HttpCache {
       // Create parent directories
       if let Some(parent) = cache_path.parent() {
         let parent_path = parent.to_string();
-        println!("Creating directory: {:?}", parent_path);
         let parent_utf8_path = Utf8Path::new(&parent_path);
-        match self.filesystem.create_dir_all(parent_utf8_path).await {
-          Ok(_) => println!("Created cache directory successfully"),
-          Err(e) => println!("Failed to create cache directory: {:?}", e),
-        };
+        self.filesystem.create_dir_all(parent_utf8_path).await.ok();
       }
 
       // Write the cache file
-      println!("Writing cache file to: {:?}", cache_path);
-      match self.filesystem.write(cache_path, content).await {
-        Ok(_) => println!("Wrote cache file successfully"),
-        Err(e) => println!("Failed to write cache file: {:?}", e),
-      };
-    } else {
-      println!("No cache location specified");
+      self.filesystem.write(cache_path, content).await.ok();
     }
     Ok(())
   }

crates/rspack_plugin_schemes/src/http_uri/lockfile.rs

@@ -187,8 +187,8 @@ impl LockfileCache {
         Err(e) if e.kind() == io::ErrorKind::NotFound => {
           // File doesn't exist, use the default empty lockfile
         }
-        Err(e) => {
-          eprintln!("Error reading lockfile: {:?}", e);
+        Err(_e) => {
+          // Error reading lockfile
         }
       }
     }

crates/rspack_plugin_schemes/src/http_uri/mod.rs

@@ -9,14 +9,15 @@ pub use http_cache::{HttpClient, HttpResponse};
 use once_cell::sync::Lazy;
 use regex::Regex;
 use rspack_core::{
-  get_scheme, ApplyContext, CompilerOptions, Content, ModuleFactoryCreateData,
+  ApplyContext, CompilerOptions, Content, ModuleFactoryCreateData,
   NormalModuleFactoryResolveForScheme, NormalModuleFactoryResolveInScheme,
   NormalModuleReadResource, Plugin, PluginContext, ResourceData, Scheme,
 };
 use rspack_error::Result;
 use rspack_fs::WritableFileSystem;
 use rspack_hook::{plugin, plugin_hook};
 use rspack_util::asset_condition::{AssetCondition, AssetConditions};
+use url::Url;
 
 static EXTERNAL_HTTP_REQUEST: Lazy<Regex> =
   Lazy::new(|| Regex::new(r"^(//|https?://|#)").expect("Invalid regex"));
@@ -31,6 +32,25 @@ impl HttpUriPlugin {
   pub fn new(options: HttpUriPluginOptions) -> Self {
     Self::new_inner(options)
   }
+  pub async fn respond_with_url_module(
+    &self,
+    resource_data: &mut ResourceData,
+    url: &Url,
+    mimetype: Option<String>,
+  ) -> Result<bool> {
+    resource_data.set_resource(url.to_string());
+    resource_data.set_path(url.origin().ascii_serialization() + url.path());
+    if let Some(query) = url.query() {
+      resource_data.set_query(query.to_string());
+    }
+    if let Some(fragment) = url.fragment() {
+      resource_data.set_fragment(fragment.to_string());
+    }
+    if let Some(mime) = mimetype {
+      resource_data.set_mimetype(mime);
+    }
+    Ok(true)
+  }
 }
 
 #[derive(Debug)]
@@ -49,14 +69,21 @@ pub struct HttpUriPluginOptions {
 async fn resolve_for_scheme(
   &self,
   _data: &mut ModuleFactoryCreateData,
-  _resource_data: &mut ResourceData,
-  scheme: &Scheme,
+  resource_data: &mut ResourceData,
+  _scheme: &Scheme,
 ) -> Result<Option<bool>> {
-  Ok(if scheme.is_http() || scheme.is_https() {
-    Some(true)
-  } else {
-    None
-  })
+  // Try to parse the URL and handle it
+  match Url::parse(&resource_data.resource) {
+    Ok(url) => match self
+      .respond_with_url_module(resource_data, &url, None)
+      .await
+    {
+      Ok(true) => Ok(Some(true)),
+      Ok(false) => Ok(None),
+      Err(e) => Err(e),
+    },
+    Err(_) => Ok(None),
+  }
 }
 
 #[plugin_hook(NormalModuleFactoryResolveInScheme for HttpUriPlugin)]
@@ -66,31 +93,42 @@ async fn resolve_in_scheme(
   resource_data: &mut ResourceData,
   _scheme: &Scheme,
 ) -> Result<Option<bool>> {
-  if !matches!(
-    get_scheme(data.context.as_str()),
-    Scheme::Http | Scheme::Https
-  ) {
+  // Check if the dependency type is "url", similar to webpack's check
+  let is_not_url_dependency = data
+    .dependencies
+    .first()
+    .and_then(|dep| dep.as_module_dependency())
+    .map(|dep| dep.dependency_type().as_str() != "url")
+    .unwrap_or(true);
+
+  // Only handle relative urls (./xxx, ../xxx, /xxx, //xxx) and non-url dependencies
+  if is_not_url_dependency
+    && (!resource_data.resource.starts_with("./")
+      && !resource_data.resource.starts_with("../")
+      && !resource_data.resource.starts_with("/")
+      && !resource_data.resource.starts_with("//"))
+  {
     return Ok(None);
   }
 
-  let base_url = match url::Url::parse(data.context.as_str()) {
+  // Parse the base URL from context
+  let base_url = match Url::parse(&format!("{}/", data.context)) {
     Ok(url) => url,
     Err(_) => return Ok(None),
   };
 
-  let resource_url = match url::Url::parse(&resource_data.resource) {
-    Ok(url) if url.scheme() == "http" || url.scheme() == "https" => return Ok(None),
-    Ok(_) | Err(_) => resource_data.resource.clone(),
-  };
-
-  let resource_set = base_url
-    .join(&resource_url)
-    .map(|url| url.to_string())
-    .unwrap_or_else(|_| resource_data.resource.clone());
-
-  resource_data.set_resource(resource_set);
-
-  Ok(Some(true))
+  // Join the base URL with the resource
+  match base_url.join(&resource_data.resource) {
+    Ok(url) => match self
+      .respond_with_url_module(resource_data, &url, None)
+      .await
+    {
+      Ok(true) => Ok(Some(true)),
+      Ok(false) => Ok(None),
+      Err(e) => Err(e),
+    },
+    Err(_) => Ok(None),
+  }
 }
 
 #[plugin_hook(NormalModuleReadResource for HttpUriPlugin)]

examples/basic/rspack.config.cjs

@@ -1,6 +1,6 @@
 module.exports = {
 	context: __dirname,
 	entry: {
-		main: './index.js'
+		main: "./index.js"
 	}
-}
+};

packages/rspack-test-tools/tests/configCases/build-http/asset/index.js

@@ -1,8 +1,11 @@
-const urlSvg = new URL(
+import url1 from "https://raw.githubusercontent.com/web-infra-dev/rspack/55d5d81/packages/rspack-test-tools/tests/configCases/asset/_images/file.png";
+
+const url2 = new URL(
 	"https://raw.githubusercontent.com/web-infra-dev/rspack/55d5d81/packages/rspack-test-tools/tests/configCases/asset/_images/file.jpg",
 	import.meta.url
 );
 
 it("should work", () => {
-	expect(/[\da-f]{16}\.jpg$/.test(urlSvg)).toBe(true);
+	expect(/[\da-f]{16}\.png$/.test(url1)).toBe(true);
+	expect(/[\da-f]{16}\.jpg$/.test(url2)).toBe(true);
 });

packages/rspack-test-tools/tests/configCases/build-http/asset/lock-files/lock.json

@@ -7,6 +7,13 @@
       "content_type": "image/jpeg",
       "valid_until": 1742905466911,
       "etag": "W/\"40111d35223d236145879eff0356549b1c5e1e09d728cc3006096a31617decdb\""
+    },
+    "https://raw.githubusercontent.com/web-infra-dev/rspack/55d5d81/packages/rspack-test-tools/tests/configCases/asset/_images/file.png": {
+      "resolved": "https://raw.githubusercontent.com/web-infra-dev/rspack/55d5d81/packages/rspack-test-tools/tests/configCases/asset/_images/file.png",
+      "integrity": "sha512-atUj9bZUhzadMFYTNmufaNze7iJSkXZuOyX69FQ5ygafYUAwwIylTHFP2/epRPrEibFRWov54NMZHhvLv+ap3w==",
+      "content_type": "image/png",
+      "valid_until": 1743141759795,
+      "etag": "W/\"70f400bdbff19f7b1859bc4856f593134cfad96dd1f157b19647bdce9bef5433\""
     }
   }
 }

packages/rspack-test-tools/tests/configCases/build-http/asset/lock-files/test/https___raw.githubusercontent.com/_web-infra-dev_rspack_55d5d81_packages_rspack-test-tools_tests_configCases_asset__images_file_a661b00f00235b3186ff.png

@@ -3,6 +3,14 @@ const path = require("path");
 /** @type {import("@rspack/core").Configuration} */
 module.exports = {
 	mode: "development",
+	module: {
+		rules: [
+			{
+				test: /\.png$/,
+				type: "asset/resource"
+			}
+		]
+	},
 	experiments: {
 		buildHttp: {
 			allowedUris: ["https://"],

packages/rspack-test-tools/tests/configCases/build-http/asset/webpack.config.js

@@ -1,5 +1,15 @@
 Array [
-  "/* #region \"./style.css\" */
+  "/* #region \"https://raw.githubusercontent.com/web-infra-dev/rspack/55d5d81/packages/rspack-test-tools/tests/configCases/css/at-import/c.css\" */
+/*
+- type: css/auto
+*/
+.c {
+	color: pink;
+}
+
+/* #endregion \"https://raw.githubusercontent.com/web-infra-dev/rspack/55d5d81/packages/rspack-test-tools/tests/configCases/css/at-import/c.css\" */
+
+/* #region \"./style.css\" */
 /*
 - type: css/auto
 */
@@ -12,7 +22,17 @@ div {
 /* #endregion \"./style.css\" */
 
 ",
-  "/* #region \"./style.css\" */
+  "/* #region \"https://raw.githubusercontent.com/web-infra-dev/rspack/55d5d81/packages/rspack-test-tools/tests/configCases/css/at-import/c.css\" */
+/*
+- type: css/auto
+*/
+.c {
+	color: pink;
+}
+
+/* #endregion \"https://raw.githubusercontent.com/web-infra-dev/rspack/55d5d81/packages/rspack-test-tools/tests/configCases/css/at-import/c.css\" */
+
+/* #region \"./style.css\" */
 /*
 - type: css/auto
 */