@lovrozagar/honey 0.6.5 → 0.7.0

package/dist/client-rust/invalidation_sync.rs

@@ -0,0 +1,93 @@
+/* Code generated by honey. DO NOT EDIT. */
+
+#![allow(dead_code)]
+
+/* Sync counterpart of StaleTracker. Uses std::sync::Mutex instead of
+   tokio::sync::Mutex so it can be called from blocking SyncClient paths
+   without requiring an async runtime. Reuses the shared StaleEntry /
+   RequestMeta types + pattern/interpolation helpers from invalidation.rs. */
+
+use crate::invalidation::{resolve_invalidation_targets_for_mutation, tracker_settings, RequestMeta, TrackerState};
+use crate::runtime::InvalidationConfig;
+use std::collections::HashMap;
+use std::sync::Mutex;
+use std::time::{Duration, Instant};
+
+/// StaleTrackerSync is the blocking counterpart of StaleTracker.
+/// All public methods are safe for concurrent blocking use (interior std Mutex).
+pub struct StaleTrackerSync {
+    state: Mutex<TrackerState>,
+    enabled: bool,
+    stale_time: Duration,
+    max_entries: usize,
+    max_sources: usize,
+}
+
+impl StaleTrackerSync {
+    /// new constructs a tracker from an InvalidationConfig.
+    /// Tracker is disabled (cheap no-op) when cfg is None or stale_time ≤ 0.
+    pub fn new(cfg: Option<&InvalidationConfig>) -> Self {
+        let (enabled, stale_time, max_entries, max_sources) = tracker_settings(cfg);
+        StaleTrackerSync { state: Mutex::new(TrackerState::default()), enabled, stale_time, max_entries, max_sources }
+    }
+
+    /// enabled reports whether the tracker will record / report stale entries.
+    pub fn enabled(&self) -> bool {
+        self.enabled
+    }
+
+    /// mark_stale bumps seq, expands templated invalidation entries with
+    /// `params`, and records each resolved target as freshly stale.
+    pub fn mark_stale(&self, invalidate: &[String], params: &HashMap<String, String>, mutation_selector: &str) {
+        if !self.enabled || invalidate.is_empty() {
+            return;
+        }
+        let mut s = self.state.lock().unwrap();
+        s.seq += 1;
+        let seq = s.seq;
+        let until = Instant::now() + self.stale_time;
+        for target in resolve_invalidation_targets_for_mutation(invalidate, params) {
+            s.upsert(&target, until, seq, mutation_selector, self.max_sources);
+        }
+        s.enforce_capacity(self.max_entries);
+    }
+
+    /// lookup_stale returns (invalidated_by, is_stale): exact + pattern lookup
+    /// with expired-key sweep. Disabled tracker → (vec![], false).
+    pub fn lookup_stale(&self, concrete_selector: &str, concrete_path: &str, method: &str, now: Instant) -> (Vec<String>, bool) {
+        if !self.enabled {
+            return (Vec::new(), false);
+        }
+        self.state.lock().unwrap().lookup(concrete_selector, concrete_path, method, now)
+    }
+
+    /// clear_stale drops stale entries whose seq ≤ seq_snapshot and which match
+    /// the given concrete_path under method (exact key + pattern keys).
+    pub fn clear_stale(&self, concrete_selector: &str, concrete_path: &str, method: &str, seq_snapshot: u64) {
+        if !self.enabled {
+            return;
+        }
+        self.state.lock().unwrap().clear(concrete_selector, concrete_path, method, seq_snapshot);
+    }
+
+    /// is_stale reports whether (method, path) currently sits inside an active
+    /// stale window. Walks pattern entries too. Disabled tracker → false.
+    pub fn is_stale(&self, method: &str, path: &str) -> bool {
+        if !self.enabled {
+            return false;
+        }
+        let selector = format!("{} {}", method, path);
+        self.state.lock().unwrap().lookup(&selector, path, method, Instant::now()).1
+    }
+
+    /// build_request_meta returns a RequestMeta snapshot for the request about
+    /// to fire, or None when tracker is disabled.
+    pub fn build_request_meta(&self, concrete_selector: &str, concrete_path: &str, method: &str) -> Option<RequestMeta> {
+        if !self.enabled {
+            return None;
+        }
+        let mut s = self.state.lock().unwrap();
+        let (by, is_stale) = s.lookup(concrete_selector, concrete_path, method, Instant::now());
+        Some(RequestMeta { selector: concrete_selector.to_string(), is_stale, invalidated_by: by, seq_snapshot: s.seq })
+    }
+}

package/dist/client-rust/nullable.rs

@@ -0,0 +1,17 @@
+/* Code generated by honey. DO NOT EDIT. */
+
+//! Optional fields that may also be null.
+//!
+//! Such a field is `Option<Option<T>>`: `None` leaves the key out, `Some(None)` sends an explicit
+//! `null`, `Some(Some(v))` a value. `#[serde(default)]` keeps a missing key `None`;
+//! `deserialize` turns a present `null` into `Some(None)` (serde alone would read it as `None`).
+
+use serde::{Deserialize, Deserializer};
+
+pub fn deserialize<'de, D, T>(deserializer: D) -> Result<Option<Option<T>>, D::Error>
+where
+    D: Deserializer<'de>,
+    T: Deserialize<'de>,
+{
+    Option::<T>::deserialize(deserializer).map(Some)
+}