rspack_storage 0.7.11

rspack cache storage
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

mod split;

use async_trait::async_trait;
use rspack_paths::{Utf8Path, Utf8PathBuf};
use rustc_hash::{FxHashMap as HashMap, FxHashSet as HashSet};
pub use split::SplitPackStrategy;

use super::data::{
  Pack, PackContents, PackFileMeta, PackGenerations, PackKeys, PackOptions, PackScope, RootMeta,
  RootOptions,
};
use crate::{
  ItemKey, ItemValue,
  error::{Result, ValidateResult},
};

pub struct UpdatePacksResult {
  pub new_packs: Vec<(PackFileMeta, Pack)>,
  pub remain_packs: Vec<(PackFileMeta, Pack)>,
  pub removed_files: Vec<Utf8PathBuf>,
}

#[async_trait]
pub trait ScopeStrategy:
  RootStrategy
  + ScopeReadStrategy
  + ScopeWriteStrategy
  + ScopeValidateStrategy
  + std::fmt::Debug
  + Sync
  + Send
{
}

#[async_trait]
pub trait RootStrategy {
  async fn before_load(&self) -> Result<()>;
  async fn read_root_meta(&self) -> Result<Option<RootMeta>>;
  async fn write_root_meta(&self, root_meta: &RootMeta) -> Result<()>;
  async fn validate_root(&self, root_meta: &RootMeta) -> Result<ValidateResult>;
  async fn clean(
    &self,
    root_meta: &RootMeta,
    scopes: &HashMap<String, PackScope>,
    root_options: &RootOptions,
  ) -> Result<()>;
  async fn reset(&self);
}

#[derive(Debug, Default)]
pub struct PackMainContents {
  pub contents: PackContents,
  pub generations: PackGenerations,
}

#[async_trait]
pub trait PackReadStrategy {
  async fn read_pack_keys(&self, path: &Utf8Path) -> Result<Option<PackKeys>>;
  async fn read_pack_contents(&self, path: &Utf8Path) -> Result<Option<PackMainContents>>;
}

#[async_trait]
pub trait PackWriteStrategy {
  async fn update_packs(
    &self,
    dir: Utf8PathBuf,
    generation: usize,
    options: &PackOptions,
    packs: HashMap<PackFileMeta, Pack>,
    updates: HashMap<ItemKey, Option<ItemValue>>,
  ) -> Result<UpdatePacksResult>;
  async fn optimize_packs(
    &self,
    dir: Utf8PathBuf,
    options: &PackOptions,
    packs: Vec<(PackFileMeta, Pack)>,
  ) -> Result<UpdatePacksResult>;
  async fn write_pack(&self, pack: &Pack) -> Result<()>;
}

#[async_trait]
pub trait ScopeReadStrategy {
  fn get_path(&self, sub: &str) -> Utf8PathBuf;
  async fn ensure_meta(&self, scope: &mut PackScope) -> Result<()>;
  async fn ensure_packs(&self, scope: &mut PackScope) -> Result<()>;
  async fn ensure_keys(&self, scope: &mut PackScope) -> Result<()>;
  async fn ensure_contents(&self, scope: &mut PackScope) -> Result<()>;
}

#[async_trait]
pub trait ScopeValidateStrategy {
  async fn validate_meta(&self, scope: &mut PackScope) -> Result<ValidateResult>;
  async fn validate_packs(&self, scope: &mut PackScope) -> Result<ValidateResult>;
}

#[derive(Debug, Default, Clone)]
pub struct WriteScopeResult {
  pub wrote_files: HashSet<Utf8PathBuf>,
  pub removed_files: HashSet<Utf8PathBuf>,
}

impl WriteScopeResult {
  pub fn extend(&mut self, other: Self) {
    self.wrote_files.extend(other.wrote_files);
    self.removed_files.extend(other.removed_files);
  }
}

pub type ScopeUpdate = HashMap<ItemKey, Option<ItemValue>>;
#[async_trait]
pub trait ScopeWriteStrategy {
  async fn update_scope(&self, scope: &mut PackScope, updates: ScopeUpdate) -> Result<()>;
  async fn before_all(&self, scopes: &mut HashMap<String, PackScope>) -> Result<()>;
  async fn optimize_scope(&self, scope: &mut PackScope) -> Result<()>;
  async fn release_scope(&self, scope: &mut PackScope) -> Result<()>;
  async fn write_packs(&self, scope: &mut PackScope) -> Result<WriteScopeResult>;
  async fn write_meta(&self, scope: &mut PackScope) -> Result<WriteScopeResult>;
  async fn merge_changed(&self, changed: WriteScopeResult) -> Result<()>;
  async fn after_all(&self, scopes: &mut HashMap<String, PackScope>) -> Result<()>;
}