Skip to main content

rip_settings/
repository.rs

1use crate::backend::SettingsBackend;
2use crate::error::SettingsError;
3use crate::schema::SettingsSchema;
4use crate::validation;
5use crate::validation::ValidationResult;
6use std::sync::{Arc, Mutex, RwLock};
7use tokio::sync::watch;
8
9pub type ChangeListener<T> = Box<dyn Fn(&str, &T, &T) + Send + Sync>;
10
11/// Repository for reading/writing settings via a pluggable backend.
12pub struct SettingsRepository<T: SettingsSchema> {
13    backend: Box<dyn SettingsBackend>,
14    current: Mutex<T>,
15    sender: watch::Sender<T>,
16    receiver: watch::Receiver<T>,
17    change_listeners: Arc<RwLock<Vec<ChangeListener<T>>>>,
18}
19
20impl<T: SettingsSchema + PartialEq> SettingsRepository<T> {
21    pub fn new(backend: Box<dyn SettingsBackend>) -> Self {
22        let initial = Self::load_from_backend(&*backend);
23        let (sender, receiver) = watch::channel(initial.clone());
24        Self {
25            backend,
26            current: Mutex::new(initial),
27            sender,
28            receiver,
29            change_listeners: Arc::new(RwLock::new(Vec::new())),
30        }
31    }
32
33    /// Get the current settings value.
34    pub fn get(&self) -> T {
35        self.current
36            .lock()
37            .unwrap_or_else(|e| e.into_inner())
38            .clone()
39    }
40
41    /// Update settings with a mutation function.
42    /// Validates all fields after mutation - if validation fails, the mutation is not persisted.
43    pub fn update(&self, f: impl FnOnce(&mut T)) -> Result<(), SettingsError> {
44        let mut guard = self
45            .current
46            .lock()
47            .map_err(|e| SettingsError::LockPoisoned(e.to_string()))?;
48        let old = guard.clone();
49        let mut candidate = old.clone();
50        f(&mut candidate);
51
52        if old == candidate {
53            return Ok(());
54        }
55
56        // Validate all fields after mutation
57        for field in candidate.fields() {
58            if let Some(ref rules) = field.validation {
59                if let Ok(val) = candidate.get_field_value(field.name) {
60                    if let ValidationResult::Invalid(msg) = validation::validate_value(&val, rules)
61                    {
62                        return Err(SettingsError::ValidationFailed(msg));
63                    }
64                }
65            }
66        }
67
68        *guard = candidate;
69        self.persist(&guard)?;
70        let _ = self.sender.send(guard.clone());
71
72        let fields = guard.fields();
73        for field in &fields {
74            if old.get_field_value(field.name).ok() != guard.get_field_value(field.name).ok() {
75                self.notify_change(field.name, &old, &guard);
76            }
77        }
78
79        Ok(())
80    }
81
82    /// Set a single field by name from a JSON value.
83    pub fn set_field(&self, name: &str, value: serde_json::Value) -> Result<(), SettingsError> {
84        let mut guard = self
85            .current
86            .lock()
87            .map_err(|e| SettingsError::LockPoisoned(e.to_string()))?;
88
89        if let Some(field_meta) = guard.field_by_name(name) {
90            if let Some(ref rules) = field_meta.validation {
91                let result = validation::validate_value(&value, rules);
92                if let ValidationResult::Invalid(msg) = result {
93                    return Err(SettingsError::ValidationFailed(msg));
94                }
95            }
96        }
97
98        let old = guard.clone();
99        guard.set_field_value(name, value)?;
100
101        if old == *guard {
102            return Ok(());
103        }
104
105        self.persist(&guard)?;
106        let _ = self.sender.send(guard.clone());
107        self.notify_change(name, &old, &guard);
108
109        Ok(())
110    }
111
112    /// Get a single field value by name as JSON.
113    pub fn get_field(&self, name: &str) -> Result<serde_json::Value, SettingsError> {
114        self.get().get_field_value(name)
115    }
116
117    /// Subscribe to changes (returns a watch receiver).
118    pub fn subscribe(&self) -> watch::Receiver<T> {
119        self.receiver.clone()
120    }
121
122    /// Add a change listener.
123    pub fn add_change_listener(&self, listener: ChangeListener<T>) {
124        self.change_listeners
125            .write()
126            .unwrap_or_else(|e| e.into_inner())
127            .push(listener);
128    }
129
130    /// Reload settings from the backend.
131    pub fn reload(&self) -> Result<(), SettingsError> {
132        let loaded = Self::load_from_backend(&*self.backend);
133        let mut guard = self
134            .current
135            .lock()
136            .map_err(|e| SettingsError::LockPoisoned(e.to_string()))?;
137        *guard = loaded.clone();
138        let _ = self.sender.send(loaded);
139        Ok(())
140    }
141
142    /// Reset all settings to defaults and persist.
143    pub fn reset_all(&self) -> Result<(), SettingsError> {
144        let defaults = T::default();
145        let mut guard = self
146            .current
147            .lock()
148            .map_err(|e| SettingsError::LockPoisoned(e.to_string()))?;
149        *guard = defaults;
150        self.persist(&guard)?;
151        let _ = self.sender.send(guard.clone());
152        Ok(())
153    }
154
155    /// Reset a single field to its default.
156    pub fn reset_field(&self, name: &str) -> Result<(), SettingsError> {
157        let defaults = T::default();
158        let default_value = defaults.get_field_value(name)?;
159        self.set_field(name, default_value)
160    }
161
162    /// Get the backend reference (for backup manager, etc.).
163    pub fn backend(&self) -> &dyn SettingsBackend {
164        &*self.backend
165    }
166
167    fn persist(&self, value: &T) -> Result<(), SettingsError> {
168        let data = serde_json::to_vec_pretty(value)?;
169        self.backend.save(&data)
170    }
171
172    fn load_from_backend(backend: &dyn SettingsBackend) -> T {
173        match backend.load() {
174            Ok(data) if !data.is_empty() => serde_json::from_slice(&data).unwrap_or_default(),
175            _ => T::default(),
176        }
177    }
178
179    fn notify_change(&self, field_name: &str, old: &T, new: &T) {
180        if let Ok(listeners) = self.change_listeners.read() {
181            for listener in listeners.iter() {
182                listener(field_name, old, new);
183            }
184        }
185    }
186}