fix: context dependencies hash calculation use cache.snapshot configuration (#12947)

fix: context dependencies hash calculation use cache.snapshot configuration (#12937)

* fix: snapshot watch symlink

* fix: context dependencies use snapshot options

* test: update test case

Author: jerrykingxyz

crates/rspack_core/src/cache/persistent/snapshot/mod.rs

@@ -68,7 +68,7 @@ impl Snapshot {
 
   #[tracing::instrument("Cache::Snapshot::add", skip_all)]
   pub async fn add(&self, scope: SnapshotScope, paths: impl Iterator<Item = ArcPath>) {
-    let helper = Arc::new(StrategyHelper::new(self.fs.clone()));
+    let helper = Arc::new(StrategyHelper::new(self.fs.clone(), self.options.clone()));
     let codec = self.codec.clone();
     // TODO merge package version file
     paths
@@ -109,7 +109,7 @@ impl Snapshot {
     let mut modified_path = ArcPathSet::default();
     let mut deleted_path = ArcPathSet::default();
     let mut no_change_path = ArcPathSet::default();
-    let helper = Arc::new(StrategyHelper::new(self.fs.clone()));
+    let helper = Arc::new(StrategyHelper::new(self.fs.clone(), self.options.clone()));
     let codec = self.codec.clone();
 
     let data = self.storage.load(scope.name()).await?;

crates/rspack_core/src/cache/persistent/snapshot/strategy/hash_helper.rs

@@ -7,6 +7,8 @@ use rspack_fs::{FileMetadata, ReadableFileSystem};
 use rspack_paths::{ArcPath, ArcPathDashMap, AssertUtf8};
 use rustc_hash::FxHasher;
 
+use super::{PackageHelper, SnapshotOptions};
+
 /// Content hash with modification time.
 #[derive(Debug, Clone, Default)]
 pub struct ContentHash {
@@ -17,26 +19,31 @@ pub struct ContentHash {
 /// A helper for computing content hashes of files and directories.
 #[derive(Debug)]
 pub struct HashHelper {
-  /// File system abstraction for reading file contents.
   fs: Arc<dyn ReadableFileSystem>,
-
-  /// Cache for file content hashes.
+  snapshot_options: Arc<SnapshotOptions>,
+  package_helper: Arc<PackageHelper>,
   file_cache: ArcPathDashMap<Option<ContentHash>>,
-  /// Cache for directory content hashes.
   dir_cache: ArcPathDashMap<Option<ContentHash>>,
 }
 
 impl HashHelper {
   /// Creates a new HashHelper instance with the given file system.
-  pub fn new(fs: Arc<dyn ReadableFileSystem>) -> Self {
+  pub fn new(
+    fs: Arc<dyn ReadableFileSystem>,
+    snapshot_options: Arc<SnapshotOptions>,
+    package_helper: Arc<PackageHelper>,
+  ) -> Self {
     Self {
       fs,
+      snapshot_options,
+      package_helper,
       file_cache: Default::default(),
       dir_cache: Default::default(),
     }
   }
 
-  /// Calculate file hash, return default for non-files.
+  /// Computes content hash for a file.
+  /// Returns None if the file does not exist.
   async fn inner_file_hash(
     &self,
     path: &ArcPath,
@@ -57,28 +64,26 @@ impl HashHelper {
       metadata
     };
 
-    let hash = if metadata.is_file && !metadata.is_symlink {
-      if let Ok(content) = self.fs.read(utf8_path).await {
-        // mtime is the larger of ctime and mtime
-        let mtime = if metadata.ctime_ms > metadata.mtime_ms {
-          metadata.ctime_ms
-        } else {
-          metadata.mtime_ms
-        };
-        let mut hasher = FxHasher::default();
-        content.hash(&mut hasher);
-        Some(ContentHash {
-          hash: hasher.finish(),
-          mtime,
-        })
-      } else {
-        None
-      }
+    // mtime is the larger of ctime and mtime
+    let mtime = if metadata.ctime_ms > metadata.mtime_ms {
+      metadata.ctime_ms
     } else {
-      // directory & symlink
-      Some(ContentHash::default())
+      metadata.mtime_ms
     };
-
+    let mut hasher = FxHasher::default();
+    if metadata.is_symlink {
+      if let Ok(target) = self.fs.canonicalize(utf8_path).await {
+        target.hash(&mut hasher)
+      }
+    } else if metadata.is_file
+      && let Ok(content) = self.fs.read(utf8_path).await
+    {
+      content.hash(&mut hasher);
+    };
+    let hash = Some(ContentHash {
+      hash: hasher.finish(),
+      mtime,
+    });
     self.file_cache.insert(path.into(), hash.clone());
     hash
   }
@@ -103,10 +108,21 @@ impl HashHelper {
 
     let hash = if metadata.is_directory && !metadata.is_symlink {
       if let Ok(mut children) = self.fs.read_dir(utf8_path).await {
-        children.sort();
         let mut hasher = FxHasher::default();
+        children.sort();
         for item in children {
           let child_path = ArcPath::from(path.join(item));
+          let child_path_str = child_path.to_string_lossy();
+          if self.snapshot_options.is_immutable_path(&child_path_str) {
+            continue;
+          }
+          if self.snapshot_options.is_managed_path(&child_path_str) {
+            if let Some(version) = self.package_helper.package_version(&child_path).await {
+              version.hash(&mut hasher);
+            }
+            continue;
+          }
+
           if let Some(ContentHash { hash, .. }) = self.dir_hash(&child_path).await {
             hash.hash(&mut hasher);
           }
@@ -134,40 +150,57 @@ mod tests {
   use rspack_fs::{MemoryFileSystem, WritableFileSystem};
   use rspack_paths::ArcPath;
 
-  use super::HashHelper;
+  use super::{
+    super::super::super::snapshot::PathMatcher, HashHelper, PackageHelper, SnapshotOptions,
+  };
+
+  fn new_helper(fs: Arc<MemoryFileSystem>) -> HashHelper {
+    HashHelper::new(
+      fs.clone(),
+      Arc::new(SnapshotOptions::new(
+        vec![PathMatcher::String("immutable".into())],
+        vec![],
+        vec![PathMatcher::String("node_modules".into())],
+      )),
+      Arc::new(PackageHelper::new(fs)),
+    )
+  }
 
   #[tokio::test]
   async fn file_hash() {
     let fs = Arc::new(MemoryFileSystem::default());
     fs.create_dir_all("/".into()).await.unwrap();
     fs.write("/hash.js".into(), "abc".as_bytes()).await.unwrap();
 
-    let helper = HashHelper::new(fs.clone());
+    let helper = new_helper(fs.clone());
     assert!(
       helper
         .file_hash(&ArcPath::from("/not_exist.js"))
         .await
         .is_none()
     );
+    // check directory
     let hash0 = helper.file_hash(&ArcPath::from("/")).await.unwrap();
     assert_eq!(hash0.hash, 0);
-    assert_eq!(hash0.mtime, 0);
 
     let hash1 = helper.file_hash(&ArcPath::from("/hash.js")).await.unwrap();
 
-    helper.file_cache.clear();
     std::thread::sleep(std::time::Duration::from_millis(100));
+    // do nothing
+    let helper = new_helper(fs.clone());
     let hash2 = helper.file_hash(&ArcPath::from("/hash.js")).await.unwrap();
     assert_eq!(hash1.hash, hash2.hash);
     assert_eq!(hash1.mtime, hash2.mtime);
 
-    helper.file_cache.clear();
+    // same content
+    let helper = new_helper(fs.clone());
     fs.write("/hash.js".into(), "abc".as_bytes()).await.unwrap();
     let hash3 = helper.file_hash(&ArcPath::from("/hash.js")).await.unwrap();
     assert_eq!(hash1.hash, hash3.hash);
     assert!(hash1.mtime < hash3.mtime);
 
-    helper.file_cache.clear();
+    // diff content
+    let helper = new_helper(fs.clone());
     fs.write("/hash.js".into(), "abcd".as_bytes())
       .await
       .unwrap();
@@ -180,35 +213,106 @@ mod tests {
   async fn dir_hash() {
     let fs = Arc::new(MemoryFileSystem::default());
     fs.create_dir_all("/a".into()).await.unwrap();
+    fs.create_dir_all("/node_modules/lib".into()).await.unwrap();
     fs.write("/a/a1.js".into(), "a1".as_bytes()).await.unwrap();
     fs.write("/a/a2.js".into(), "a2".as_bytes()).await.unwrap();
     fs.write("/b.js".into(), "b".as_bytes()).await.unwrap();
+    fs.write("/immutable.js".into(), "immut".as_bytes())
+      .await
+      .unwrap();
+    fs.write(
+      "/node_modules/lib/index.js".into(),
+      "const a = 1".as_bytes(),
+    )
+    .await
+    .unwrap();
+    fs.write(
+      "/node_modules/lib/package.json".into(),
+      r#"{"version": "0.0.1"}"#.as_bytes(),
+    )
+    .await
+    .unwrap();
 
-    let helper = HashHelper::new(fs.clone());
-
+    let helper = new_helper(fs.clone());
     let hash1 = helper.dir_hash(&ArcPath::from("/")).await.unwrap();
+    assert_eq!(hash1.mtime, 0);
 
-    helper.file_cache.clear();
-    helper.dir_cache.clear();
     std::thread::sleep(std::time::Duration::from_millis(100));
+
+    // do nothing
+    let helper = new_helper(fs.clone());
     let hash2 = helper.dir_hash(&ArcPath::from("/")).await.unwrap();
     assert_eq!(hash1.hash, hash2.hash);
-    assert_eq!(hash1.mtime, 0);
     assert_eq!(hash2.mtime, 0);
 
-    helper.file_cache.clear();
-    helper.dir_cache.clear();
     std::thread::sleep(std::time::Duration::from_millis(100));
+
+    // do something will not update hash
+    let helper = new_helper(fs.clone());
+    // write same content
     fs.write("/a/a2.js".into(), "a2".as_bytes()).await.unwrap();
+    // edit immutable file
+    fs.write("/immutable.js".into(), "next".as_bytes())
+      .await
+      .unwrap();
+    // edit node_modules file
+    fs.write(
+      "/node_modules/lib/index.js".into(),
+      "const a = 2".as_bytes(),
+    )
+    .await
+    .unwrap();
+    // update package.json
+    fs.write(
+      "/node_modules/lib/package.json".into(),
+      r#"{"version": "0.0.2"}"#.as_bytes(),
+    )
+    .await
+    .unwrap();
     let hash3 = helper.dir_hash(&ArcPath::from("/")).await.unwrap();
-    assert_eq!(hash1.hash, hash3.hash);
+    assert_eq!(hash2.hash, hash3.hash);
     assert_eq!(hash3.mtime, 0);
 
-    helper.file_cache.clear();
-    helper.dir_cache.clear();
+    // update file content
+    let helper = new_helper(fs.clone());
     fs.write("/a/a2.js".into(), "a2a".as_bytes()).await.unwrap();
     let hash4 = helper.dir_hash(&ArcPath::from("/")).await.unwrap();
-    assert_ne!(hash1.hash, hash4.hash);
+    assert_ne!(hash3.hash, hash4.hash);
     assert_eq!(hash4.mtime, 0);
+
+    // node_modules lib test
+    let helper = new_helper(fs.clone());
+    let hash1 = helper
+      .dir_hash(&ArcPath::from("/node_modules/lib/"))
+      .await
+      .unwrap();
+
+    // update lib content
+    let helper = new_helper(fs.clone());
+    fs.write(
+      "/node_modules/lib/index.js".into(),
+      "const a = 3".as_bytes(),
+    )
+    .await
+    .unwrap();
+    let hash2 = helper
+      .dir_hash(&ArcPath::from("/node_modules/lib/"))
+      .await
+      .unwrap();
+    assert_eq!(hash1.hash, hash2.hash);
+
+    // update package.json
+    let helper = new_helper(fs.clone());
+    fs.write(
+      "/node_modules/lib/package.json".into(),
+      r#"{"version": "0.0.3"}"#.as_bytes(),
+    )
+    .await
+    .unwrap();
+    let hash2 = helper
+      .dir_hash(&ArcPath::from("/node_modules/lib/"))
+      .await
+      .unwrap();
+    assert_ne!(hash1.hash, hash2.hash);
   }
 }