feat(persistent cache): add snapshot module (#8424)

* feat: add snapshot

* feat: add js api

* fix: clippy

* fix: ci

* fix: js api remove type disable

* refactor: update strategy lib version to package version

Author: jerrykingxyz

Cargo.lock

@@ -1336,11 +1336,28 @@ export interface RawEvalDevToolModulePluginOptions {
   sourceUrlComment?: string
 }
 
+export interface RawExperimentCacheOptionsCommon {
+  type: "disable"|"memory"
+}
+
+export interface RawExperimentCacheOptionsPersistent {
+  type: "persistent"
+  snapshot: RawExperimentSnapshotOptions
+  storage: Array<RawStorageOptions>
+}
+
 export interface RawExperiments {
   layers: boolean
   topLevelAwait: boolean
   incremental?: RawIncremental
   rspackFuture: RawRspackFuture
+  cache: RawExperimentCacheOptionsPersistent | RawExperimentCacheOptionsCommon
+}
+
+export interface RawExperimentSnapshotOptions {
+  immutablePaths: Array<string|RegExp>
+  unmanagedPaths: Array<string|RegExp>
+  managedPaths: Array<string|RegExp>
 }
 
 export interface RawExposeOptions {
@@ -1940,6 +1957,11 @@ export interface RawStatsOptions {
   colors: boolean
 }
 
+export interface RawStorageOptions {
+  type: "filesystem"
+  directory: string
+}
+
 export interface RawSwcJsMinimizerOptions {
   compress: any
   mangle: any

crates/node_binding/binding.d.ts

@@ -70,54 +70,10 @@ impl TryFrom<RawOptions> for CompilerOptions {
     let mode = value.mode.unwrap_or_default().into();
     let module: ModuleOptions = value.module.try_into()?;
     let cache = value.cache.into();
-    let experiments = Experiments {
-      incremental: match value.experiments.incremental {
-        Some(value) => {
-          let mut passes = IncrementalPasses::empty();
-          if !matches!(cache, CacheOptions::Disabled) && value.make {
-            passes.insert(IncrementalPasses::MAKE);
-          }
-          if value.infer_async_modules {
-            passes.insert(IncrementalPasses::INFER_ASYNC_MODULES);
-          }
-          if value.provided_exports {
-            passes.insert(IncrementalPasses::PROVIDED_EXPORTS);
-          }
-          if value.dependencies_diagnostics {
-            passes.insert(IncrementalPasses::DEPENDENCIES_DIAGNOSTICS);
-          }
-          if value.build_chunk_graph {
-            passes.insert(IncrementalPasses::BUILD_CHUNK_GRAPH);
-          }
-          if value.modules_hashes {
-            passes.insert(IncrementalPasses::MODULES_HASHES);
-          }
-          if value.modules_codegen {
-            passes.insert(IncrementalPasses::MODULES_CODEGEN);
-          }
-          if value.modules_runtime_requirements {
-            passes.insert(IncrementalPasses::MODULES_RUNTIME_REQUIREMENTS);
-          }
-          if value.chunks_runtime_requirements {
-            passes.insert(IncrementalPasses::CHUNKS_RUNTIME_REQUIREMENTS);
-          }
-          if value.chunks_hashes {
-            passes.insert(IncrementalPasses::CHUNKS_HASHES);
-          }
-          if value.chunks_render {
-            passes.insert(IncrementalPasses::CHUNKS_RENDER);
-          }
-          if value.emit_assets {
-            passes.insert(IncrementalPasses::EMIT_ASSETS);
-          }
-          passes
-        }
-        None => IncrementalPasses::empty(),
-      },
-      layers: value.experiments.layers,
-      top_level_await: value.experiments.top_level_await,
-      rspack_future: value.experiments.rspack_future.into(),
-    };
+    let mut experiments: Experiments = value.experiments.into();
+    if let CacheOptions::Disabled = cache {
+      experiments.incremental = IncrementalPasses::empty();
+    }
     let optimization = value.optimization.try_into()?;
     let stats = value.stats.into();
     let snapshot = value.snapshot.into();

crates/rspack_binding_options/src/options/mod.rs

@@ -0,0 +1,35 @@
+mod raw_cache;
+mod raw_incremental;
+mod raw_rspack_future;
+
+use napi_derive::napi;
+use raw_cache::{normalize_raw_experiment_cache_options, RawExperimentCacheOptions};
+use raw_incremental::RawIncremental;
+use raw_rspack_future::RawRspackFuture;
+use rspack_core::{incremental::IncrementalPasses, Experiments};
+
+#[derive(Debug)]
+#[napi(object)]
+pub struct RawExperiments {
+  pub layers: bool,
+  pub top_level_await: bool,
+  pub incremental: Option<RawIncremental>,
+  pub rspack_future: RawRspackFuture,
+  #[napi(ts_type = r#"RawExperimentCacheOptionsPersistent | RawExperimentCacheOptionsCommon"#)]
+  pub cache: RawExperimentCacheOptions,
+}
+
+impl From<RawExperiments> for Experiments {
+  fn from(value: RawExperiments) -> Self {
+    Self {
+      incremental: match value.incremental {
+        Some(value) => value.into(),
+        None => IncrementalPasses::empty(),
+      },
+      layers: value.layers,
+      top_level_await: value.top_level_await,
+      rspack_future: value.rspack_future.into(),
+      cache: normalize_raw_experiment_cache_options(value.cache),
+    }
+  }
+}

crates/rspack_binding_options/src/options/raw_experiments.rs

@@ -0,0 +1,49 @@
+mod raw_snapshot;
+mod raw_storage;
+
+use napi::Either;
+use napi_derive::napi;
+use raw_snapshot::RawExperimentSnapshotOptions;
+use raw_storage::RawStorageOptions;
+use rspack_core::{cache::persistent::PersistentCacheOptions, ExperimentCacheOptions};
+
+pub type RawExperimentCacheOptions =
+  Either<RawExperimentCacheOptionsPersistent, RawExperimentCacheOptionsCommon>;
+
+#[derive(Debug, Default)]
+#[napi(object)]
+pub struct RawExperimentCacheOptionsCommon {
+  #[napi(ts_type = r#""disable"|"memory""#)]
+  pub r#type: String,
+}
+
+#[derive(Debug, Default)]
+#[napi(object)]
+pub struct RawExperimentCacheOptionsPersistent {
+  #[napi(ts_type = r#""persistent""#)]
+  pub r#type: String,
+  //  pub build_dependencies: Vec<String>,
+  //  pub version: String,
+  pub snapshot: RawExperimentSnapshotOptions,
+  pub storage: Vec<RawStorageOptions>,
+}
+
+pub fn normalize_raw_experiment_cache_options(
+  options: RawExperimentCacheOptions,
+) -> ExperimentCacheOptions {
+  match options {
+    Either::A(persistent_options) => ExperimentCacheOptions::Persistent(PersistentCacheOptions {
+      snapshot: persistent_options.snapshot.into(),
+      storage: persistent_options
+        .storage
+        .into_iter()
+        .map(Into::into)
+        .collect(),
+    }),
+    Either::B(options) => match options.r#type.as_str() {
+      "disable" => ExperimentCacheOptions::Disabled,
+      "memory" => ExperimentCacheOptions::Memory,
+      _ => panic!("unsupported cache type"),
+    },
+  }
+}

crates/rspack_binding_options/src/options/raw_experiments/mod.rs

@@ -0,0 +1,46 @@
+use napi::Either;
+use napi_derive::napi;
+use rspack_core::cache::persistent::snapshot::{PathMatcher, SnapshotOptions};
+use rspack_regex::RspackRegex;
+
+#[derive(Debug, Default)]
+#[napi(object)]
+pub struct RawExperimentSnapshotOptions {
+  #[napi(ts_type = r#"Array<string|RegExp>"#)]
+  pub immutable_paths: Vec<RawPathMatcher>,
+  #[napi(ts_type = r#"Array<string|RegExp>"#)]
+  pub unmanaged_paths: Vec<RawPathMatcher>,
+  #[napi(ts_type = r#"Array<string|RegExp>"#)]
+  pub managed_paths: Vec<RawPathMatcher>,
+}
+
+type RawPathMatcher = Either<String, RspackRegex>;
+
+impl From<RawExperimentSnapshotOptions> for SnapshotOptions {
+  fn from(value: RawExperimentSnapshotOptions) -> Self {
+    SnapshotOptions::new(
+      value
+        .immutable_paths
+        .into_iter()
+        .map(normalize_raw_path_matcher)
+        .collect(),
+      value
+        .unmanaged_paths
+        .into_iter()
+        .map(normalize_raw_path_matcher)
+        .collect(),
+      value
+        .managed_paths
+        .into_iter()
+        .map(normalize_raw_path_matcher)
+        .collect(),
+    )
+  }
+}
+
+fn normalize_raw_path_matcher(value: RawPathMatcher) -> PathMatcher {
+  match value {
+    Either::A(s) => PathMatcher::String(s),
+    Either::B(reg) => PathMatcher::Regexp(reg),
+  }
+}

crates/rspack_binding_options/src/options/raw_experiments/raw_cache/mod.rs

@@ -0,0 +1,16 @@
+use napi_derive::napi;
+use rspack_core::cache::persistent::storage::StorageOptions;
+
+#[derive(Debug, Default)]
+#[napi(object)]
+pub struct RawStorageOptions {
+  #[napi(ts_type = r#""filesystem""#)]
+  pub r#type: String,
+  pub directory: String,
+}
+
+impl From<RawStorageOptions> for StorageOptions {
+  fn from(_value: RawStorageOptions) -> Self {
+    StorageOptions::FileSystem
+  }
+}

crates/rspack_binding_options/src/options/raw_experiments/raw_cache/raw_snapshot.rs

@@ -0,0 +1,62 @@
+use napi_derive::napi;
+use rspack_core::incremental::IncrementalPasses;
+
+#[derive(Debug, Default)]
+#[napi(object)]
+pub struct RawIncremental {
+  pub make: bool,
+  pub infer_async_modules: bool,
+  pub provided_exports: bool,
+  pub dependencies_diagnostics: bool,
+  pub build_chunk_graph: bool,
+  pub modules_hashes: bool,
+  pub modules_codegen: bool,
+  pub modules_runtime_requirements: bool,
+  pub chunks_runtime_requirements: bool,
+  pub chunks_hashes: bool,
+  pub chunks_render: bool,
+  pub emit_assets: bool,
+}
+
+impl From<RawIncremental> for IncrementalPasses {
+  fn from(value: RawIncremental) -> Self {
+    let mut passes = IncrementalPasses::empty();
+    if value.make {
+      passes.insert(IncrementalPasses::MAKE);
+    }
+    if value.infer_async_modules {
+      passes.insert(IncrementalPasses::INFER_ASYNC_MODULES);
+    }
+    if value.provided_exports {
+      passes.insert(IncrementalPasses::PROVIDED_EXPORTS);
+    }
+    if value.dependencies_diagnostics {
+      passes.insert(IncrementalPasses::DEPENDENCIES_DIAGNOSTICS);
+    }
+    if value.build_chunk_graph {
+      passes.insert(IncrementalPasses::BUILD_CHUNK_GRAPH);
+    }
+    if value.modules_hashes {
+      passes.insert(IncrementalPasses::MODULES_HASHES);
+    }
+    if value.modules_codegen {
+      passes.insert(IncrementalPasses::MODULES_CODEGEN);
+    }
+    if value.modules_runtime_requirements {
+      passes.insert(IncrementalPasses::MODULES_RUNTIME_REQUIREMENTS);
+    }
+    if value.chunks_runtime_requirements {
+      passes.insert(IncrementalPasses::CHUNKS_RUNTIME_REQUIREMENTS);
+    }
+    if value.chunks_hashes {
+      passes.insert(IncrementalPasses::CHUNKS_HASHES);
+    }
+    if value.chunks_render {
+      passes.insert(IncrementalPasses::CHUNKS_RENDER);
+    }
+    if value.emit_assets {
+      passes.insert(IncrementalPasses::EMIT_ASSETS);
+    }
+    passes
+  }
+}

crates/rspack_binding_options/src/options/raw_experiments/raw_cache/raw_storage.rs

@@ -0,0 +1,13 @@
+use napi_derive::napi;
+use rspack_core::RspackFuture;
+
+#[allow(clippy::empty_structs_with_brackets)]
+#[derive(Debug, Default)]
+#[napi(object)]
+pub struct RawRspackFuture {}
+
+impl From<RawRspackFuture> for RspackFuture {
+  fn from(_value: RawRspackFuture) -> Self {
+    Self {}
+  }
+}