@lovrozagar/honey 0.1.0

package/src/client-rust/errors.rs

@@ -0,0 +1,200 @@
+/* Code generated by honey. DO NOT EDIT. */
+
+use std::fmt;
+
+/// ApiError is the trait implemented by all SDK typed error types.
+/// Use `downcast_ref` on the inner `Box<dyn ApiError>` to discriminate by status.
+pub trait ApiError: fmt::Display + std::error::Error + Send + Sync {
+    fn status(&self) -> u16;
+    fn body(&self) -> &[u8];
+}
+
+macro_rules! define_api_error {
+    ($name:ident, $code:expr, $phrase:expr) => {
+        pub struct $name {
+            pub message: String,
+            pub body: Vec<u8>,
+            pub status_code: u16,
+            pub data: Option<serde_json::Value>,
+        }
+
+        impl fmt::Display for $name {
+            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                write!(f, "{} {}: {}", $code, $phrase, self.message)
+            }
+        }
+
+        impl fmt::Debug for $name {
+            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                write!(f, "{} {{ message: {:?}, status_code: {} }}", stringify!($name), self.message, self.status_code)
+            }
+        }
+
+        impl std::error::Error for $name {}
+
+        impl ApiError for $name {
+            fn status(&self) -> u16 {
+                $code
+            }
+            fn body(&self) -> &[u8] {
+                &self.body
+            }
+        }
+    };
+}
+
+define_api_error!(BadRequestError, 400, "Bad Request");
+define_api_error!(UnauthorizedError, 401, "Unauthorized");
+define_api_error!(ForbiddenError, 403, "Forbidden");
+define_api_error!(NotFoundError, 404, "Not Found");
+define_api_error!(ConflictError, 409, "Conflict");
+define_api_error!(UnprocessableEntityError, 422, "Unprocessable Entity");
+define_api_error!(RateLimitError, 429, "Too Many Requests");
+define_api_error!(InternalServerError, 500, "Internal Server Error");
+define_api_error!(BadGatewayError, 502, "Bad Gateway");
+define_api_error!(ServiceUnavailableError, 503, "Service Unavailable");
+define_api_error!(GatewayTimeoutError, 504, "Gateway Timeout");
+
+/// StatusError is the fallback for any non-2xx status not covered by a concrete type.
+pub struct StatusError {
+    pub message: String,
+    pub status_code: u16,
+    pub body: Vec<u8>,
+    pub data: Option<serde_json::Value>,
+}
+
+impl fmt::Display for StatusError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}: {}", self.status_code, self.message)
+    }
+}
+
+impl fmt::Debug for StatusError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "StatusError {{ status_code: {}, message: {:?} }}", self.status_code, self.message)
+    }
+}
+
+impl std::error::Error for StatusError {}
+
+impl ApiError for StatusError {
+    fn status(&self) -> u16 {
+        self.status_code
+    }
+    fn body(&self) -> &[u8] {
+        &self.body
+    }
+}
+
+/// Error is the top-level error enum for all SDK operations.
+pub enum Error {
+    /// A typed API error (non-2xx HTTP response).
+    Api(Box<dyn ApiError + Send + Sync>),
+    /// A transport-level error from reqwest.
+    Transport(reqwest::Error),
+    /// A JSON serialization/deserialization error.
+    Json(serde_json::Error),
+    /// A URL parse error.
+    UrlParse(url::ParseError),
+    /// The request was canceled before completion.
+    Canceled,
+    /// The request timed out.
+    Timeout,
+    /// Authentication expired; string carries the refresh error message.
+    AuthExpired(String),
+    /// WebSocket close frame (or stream end). `code` is the RFC 6455 status
+    /// (1005 = no status received, 1006 = abnormal / no close frame).
+    Closed { code: u16, reason: String },
+    /// Any other error not covered by the above variants.
+    Other(String),
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Error::Api(e) => write!(f, "api error: {}", e),
+            Error::Transport(e) => write!(f, "transport error: {}", e),
+            Error::Json(e) => write!(f, "json error: {}", e),
+            Error::UrlParse(e) => write!(f, "url parse error: {}", e),
+            Error::Canceled => write!(f, "request canceled"),
+            Error::Timeout => write!(f, "request timed out"),
+            Error::AuthExpired(msg) => write!(f, "auth expired: {}", msg),
+            Error::Closed { code, reason } => {
+                if reason.is_empty() {
+                    write!(f, "connection closed: {}", code)
+                } else {
+                    write!(f, "connection closed: {} {}", code, reason)
+                }
+            }
+            Error::Other(msg) => write!(f, "error: {}", msg),
+        }
+    }
+}
+
+impl fmt::Debug for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(self, f)
+    }
+}
+
+impl std::error::Error for Error {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            Error::Transport(e) => Some(e),
+            Error::Json(e) => Some(e),
+            Error::UrlParse(e) => Some(e),
+            _ => None,
+        }
+    }
+}
+
+impl From<reqwest::Error> for Error {
+    fn from(e: reqwest::Error) -> Self {
+        if e.is_timeout() {
+            Error::Timeout
+        } else {
+            Error::Transport(e)
+        }
+    }
+}
+
+impl From<serde_json::Error> for Error {
+    fn from(e: serde_json::Error) -> Self {
+        Error::Json(e)
+    }
+}
+
+impl From<url::ParseError> for Error {
+    fn from(e: url::ParseError) -> Self {
+        Error::UrlParse(e)
+    }
+}
+
+/// raise_for_status returns None for 2xx responses, Some(Error::Api(...)) for
+/// non-2xx responses, mapping to the appropriate concrete error type when known.
+pub(crate) fn raise_for_status(status: u16, body: Vec<u8>) -> Option<Error> {
+    if (200..300).contains(&status) {
+        return None;
+    }
+    let data: Option<serde_json::Value> = if body.is_empty() {
+        None
+    } else {
+        serde_json::from_slice(&body).ok()
+    };
+    let message = String::from_utf8_lossy(&body).to_string();
+    let api_err: Box<dyn ApiError + Send + Sync> = match status {
+        400 => Box::new(BadRequestError { message, body, status_code: 400, data }),
+        401 => Box::new(UnauthorizedError { message, body, status_code: 401, data }),
+        403 => Box::new(ForbiddenError { message, body, status_code: 403, data }),
+        404 => Box::new(NotFoundError { message, body, status_code: 404, data }),
+        409 => Box::new(ConflictError { message, body, status_code: 409, data }),
+        422 => Box::new(UnprocessableEntityError { message, body, status_code: 422, data }),
+        429 => Box::new(RateLimitError { message, body, status_code: 429, data }),
+        500 => Box::new(InternalServerError { message, body, status_code: 500, data }),
+        502 => Box::new(BadGatewayError { message, body, status_code: 502, data }),
+        503 => Box::new(ServiceUnavailableError { message, body, status_code: 503, data }),
+        504 => Box::new(GatewayTimeoutError { message, body, status_code: 504, data }),
+        _ => Box::new(StatusError { message, body, status_code: status, data }),
+    };
+    Some(Error::Api(api_err))
+}

package/src/client-rust/invalidation.rs

@@ -0,0 +1,441 @@
+/* Code generated by honey. DO NOT EDIT. */
+
+#![allow(dead_code)]
+
+use crate::runtime::InvalidationConfig;
+use once_cell::sync::Lazy;
+use regex::Regex;
+use std::collections::HashMap;
+use std::time::{Duration, Instant};
+use tokio::sync::Mutex;
+
+/* PLACEHOLDER_RE matches `{name}` and `:name` placeholders. */
+static PLACEHOLDER_RE: Lazy<Regex> =
+    Lazy::new(|| Regex::new(r"\{([a-zA-Z_][a-zA-Z0-9_]*)\}|:([a-zA-Z_][a-zA-Z0-9_]*)").unwrap());
+
+/* PATTERN_REGEX_CACHE caches compiled placeholder→`[^/]+` regexps per pattern key.
+ * std::sync::Mutex is fine — pure CPU work, never held across an .await point. */
+static PATTERN_REGEX_CACHE: Lazy<std::sync::Mutex<HashMap<String, Regex>>> =
+    Lazy::new(|| std::sync::Mutex::new(HashMap::new()));
+
+/// StaleEntry is the per-key invalidation record. `by` records mutation
+/// selectors that contributed to the entry, `seq` is the monotonic version
+/// stamp at write time, `until` is the absolute expiry.
+#[derive(Clone, Debug)]
+pub struct StaleEntry {
+    pub by: Vec<String>,
+    pub seq: u64,
+    pub until: Instant,
+}
+
+/// RequestMeta is the per-request invalidation snapshot consumers see on hook
+/// contexts. Mirrors TS `_RequestMeta`, Python `_RequestMeta`, Go `RequestMeta`.
+#[derive(Clone, Debug)]
+pub struct RequestMeta {
+    pub selector: String,
+    pub is_stale: bool,
+    pub invalidated_by: Vec<String>,
+    pub seq_snapshot: u64,
+}
+
+/// compile_pattern returns a cached anchored regex for the given pattern,
+/// substituting `{name}` and `:name` placeholders with `[^/]+`.
+pub fn compile_pattern(pattern: &str) -> Regex {
+    {
+        let cache = PATTERN_REGEX_CACHE.lock().unwrap();
+        if let Some(re) = cache.get(pattern) {
+            return re.clone();
+        }
+    }
+    let mut out = String::with_capacity(pattern.len() + 4);
+    out.push('^');
+    let mut last = 0usize;
+    for m in PLACEHOLDER_RE.find_iter(pattern) {
+        out.push_str(&regex::escape(&pattern[last..m.start()]));
+        out.push_str("[^/]+");
+        last = m.end();
+    }
+    out.push_str(&regex::escape(&pattern[last..]));
+    out.push('$');
+    let re = Regex::new(&out).unwrap();
+    let mut cache = PATTERN_REGEX_CACHE.lock().unwrap();
+    cache.entry(pattern.to_string()).or_insert(re).clone()
+}
+
+/// path_has_placeholders returns true when `path` contains a `{name}` or `:name` segment.
+pub fn path_has_placeholders(path: &str) -> bool {
+    PLACEHOLDER_RE.is_match(path)
+}
+
+/// path_matches_pattern returns true when `concrete_path` matches `pattern`,
+/// where `pattern` may contain `{name}` / `:name` placeholders.
+pub fn path_matches_pattern(concrete_path: &str, pattern: &str) -> bool {
+    if concrete_path == pattern {
+        return true;
+    }
+    compile_pattern(pattern).is_match(concrete_path)
+}
+
+/// interpolate_path substitutes `{name}` / `:name` placeholders in `template`
+/// using `params`. Returns Err(missing_key) if any placeholder is not in params.
+pub fn interpolate_path(
+    template: &str,
+    params: &HashMap<String, String>,
+) -> Result<String, String> {
+    if !path_has_placeholders(template) {
+        return Ok(template.to_string());
+    }
+    let mut missing: Option<String> = None;
+    let mut out = String::with_capacity(template.len());
+    let mut last = 0usize;
+    for caps in PLACEHOLDER_RE.captures_iter(template) {
+        let m = caps.get(0).unwrap();
+        out.push_str(&template[last..m.start()]);
+        let key = caps
+            .get(1)
+            .or_else(|| caps.get(2))
+            .map(|c| c.as_str())
+            .unwrap_or_default();
+        match params.get(key) {
+            Some(v) => out.push_str(&urlencoding::encode(v)),
+            None => {
+                if missing.is_none() {
+                    missing = Some(key.to_string());
+                }
+                out.push_str(m.as_str());
+            }
+        }
+        last = m.end();
+    }
+    out.push_str(&template[last..]);
+    if let Some(k) = missing {
+        return Err(k);
+    }
+    Ok(out)
+}
+
+/// resolve_invalidation_targets_for_mutation expands templated `METHOD /path/{x}`
+/// invalidation entries to concrete `METHOD /path/abc` selectors using params.
+/// Pattern-only entries (no placeholders) pass through; entries whose
+/// placeholders cannot be resolved are dropped.
+pub fn resolve_invalidation_targets_for_mutation(
+    targets: &[String],
+    params: &HashMap<String, String>,
+) -> Vec<String> {
+    let mut out = Vec::with_capacity(targets.len());
+    for entry in targets {
+        let space_idx = match entry.find(' ') {
+            Some(i) => i,
+            None => {
+                out.push(entry.clone());
+                continue;
+            }
+        };
+        let method = &entry[..space_idx];
+        let template = &entry[space_idx + 1..];
+        if !path_has_placeholders(template) {
+            out.push(entry.clone());
+            continue;
+        }
+        match interpolate_path(template, params) {
+            Ok(concrete) => out.push(format!("{} {}", method, concrete)),
+            Err(_) => continue,
+        }
+    }
+    out
+}
+
+struct TrackerState {
+    entries: HashMap<String, StaleEntry>,
+    /* insertion order; oldest at index 0 */
+    order: Vec<String>,
+    seq: u64,
+}
+
+/// StaleTracker tracks invalidation state per `METHOD /path` selector with TS-
+/// parity semantics: exact-key + pattern-key two-tier lookup, TTL stale window,
+/// LRU eviction at cap, monotonic seq for clear-after-mutate ordering.
+/// All public methods are safe for concurrent async use (interior tokio Mutex).
+pub struct StaleTracker {
+    state: Mutex<TrackerState>,
+    enabled: bool,
+    stale_time: Duration,
+    max_entries: usize,
+    max_sources: usize,
+}
+
+impl StaleTracker {
+    /// 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 mut enabled = false;
+        let mut stale_time = Duration::from_millis(0);
+        let mut max_entries = 1000usize;
+        let mut max_sources = 16usize;
+        if let Some(c) = cfg {
+            if c.stale_time > 0 {
+                enabled = true;
+                stale_time = Duration::from_millis(c.stale_time as u64);
+                if c.stale_max_entries > 0 {
+                    max_entries = c.stale_max_entries;
+                }
+                if c.max_sources_per_target > 0 {
+                    max_sources = c.max_sources_per_target;
+                }
+            }
+        }
+        StaleTracker {
+            state: Mutex::new(TrackerState {
+                entries: HashMap::new(),
+                order: Vec::new(),
+                seq: 0,
+            }),
+            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.
+    /// `mutation_selector` is appended to each entry's `by` list (capped at
+    /// max_sources, deduped).
+    pub async 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().await;
+        s.seq += 1;
+        let seq = s.seq;
+        let until = Instant::now() + self.stale_time;
+        let resolved = resolve_invalidation_targets_for_mutation(invalidate, params);
+        for target in resolved {
+            upsert_locked(&mut s, &target, until, seq, mutation_selector, self.max_sources);
+        }
+        enforce_capacity_locked(&mut s, self.max_entries);
+    }
+
+    /// lookup_stale returns (invalidated_by, is_stale): exact + pattern lookup
+    /// with expired-key sweep. Disabled tracker → (vec![], false).
+    pub async fn lookup_stale(
+        &self,
+        concrete_selector: &str,
+        concrete_path: &str,
+        method: &str,
+        now: Instant,
+    ) -> (Vec<String>, bool) {
+        if !self.enabled {
+            return (Vec::new(), false);
+        }
+        let mut s = self.state.lock().await;
+        lookup_locked(&mut s, 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 async fn clear_stale(
+        &self,
+        concrete_selector: &str,
+        concrete_path: &str,
+        method: &str,
+        seq_snapshot: u64,
+    ) {
+        if !self.enabled {
+            return;
+        }
+        let mut s = self.state.lock().await;
+        if let Some(entry) = s.entries.get(concrete_selector) {
+            if entry.seq <= seq_snapshot {
+                delete_locked(&mut s, concrete_selector);
+            }
+        }
+        let mut to_delete: Vec<String> = Vec::new();
+        for (key, entry) in s.entries.iter() {
+            if entry.seq > seq_snapshot {
+                continue;
+            }
+            if !key.contains('{') && !key.contains(':') {
+                continue;
+            }
+            let space_idx = match key.find(' ') {
+                Some(i) => i,
+                None => continue,
+            };
+            if &key[..space_idx] != method {
+                continue;
+            }
+            if path_matches_pattern(concrete_path, &key[space_idx + 1..]) {
+                to_delete.push(key.clone());
+            }
+        }
+        for key in to_delete {
+            delete_locked(&mut s, &key);
+        }
+    }
+
+    /// is_stale reports whether (method, path) currently sits inside an active
+    /// stale window. Walks pattern entries too. Disabled tracker → false.
+    pub async fn is_stale(&self, method: &str, path: &str) -> bool {
+        if !self.enabled {
+            return false;
+        }
+        let mut s = self.state.lock().await;
+        let selector = format!("{} {}", method, path);
+        let (_, is_stale) = lookup_locked(&mut s, &selector, path, method, Instant::now());
+        is_stale
+    }
+
+    /// build_request_meta returns a RequestMeta snapshot for the request about
+    /// to fire, or None when tracker is disabled.
+    pub async 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().await;
+        let (by, is_stale) =
+            lookup_locked(&mut s, concrete_selector, concrete_path, method, Instant::now());
+        Some(RequestMeta {
+            selector: concrete_selector.to_string(),
+            is_stale,
+            invalidated_by: by,
+            seq_snapshot: s.seq,
+        })
+    }
+}
+
+fn upsert_locked(
+    s: &mut TrackerState,
+    key: &str,
+    until: Instant,
+    seq: u64,
+    mutation_selector: &str,
+    max_sources: usize,
+) {
+    if let Some(existing) = s.entries.get_mut(key) {
+        existing.until = until;
+        existing.seq = seq;
+        if !mutation_selector.is_empty() && existing.by.len() < max_sources {
+            let already = existing.by.iter().any(|b| b == mutation_selector);
+            if !already {
+                existing.by.push(mutation_selector.to_string());
+            }
+        }
+        touch_order_locked(s, key);
+        return;
+    }
+    let by = if mutation_selector.is_empty() {
+        Vec::new()
+    } else {
+        vec![mutation_selector.to_string()]
+    };
+    s.entries.insert(key.to_string(), StaleEntry { by, seq, until });
+    s.order.push(key.to_string());
+}
+
+fn touch_order_locked(s: &mut TrackerState, key: &str) {
+    if let Some(idx) = s.order.iter().position(|k| k == key) {
+        s.order.remove(idx);
+    }
+    s.order.push(key.to_string());
+}
+
+fn delete_locked(s: &mut TrackerState, key: &str) {
+    if s.entries.remove(key).is_none() {
+        return;
+    }
+    if let Some(idx) = s.order.iter().position(|k| k == key) {
+        s.order.remove(idx);
+    }
+}
+
+fn lookup_locked(
+    s: &mut TrackerState,
+    concrete_selector: &str,
+    concrete_path: &str,
+    method: &str,
+    now: Instant,
+) -> (Vec<String>, bool) {
+    let mut all_by: Vec<String> = Vec::new();
+    let mut exact_expired = false;
+    if let Some(exact) = s.entries.get(concrete_selector) {
+        if exact.until > now {
+            all_by.extend(exact.by.iter().cloned());
+        } else {
+            exact_expired = true;
+        }
+    }
+    if exact_expired {
+        delete_locked(s, concrete_selector);
+    }
+    let mut expired: Vec<String> = Vec::new();
+    for (key, entry) in s.entries.iter() {
+        if entry.until <= now {
+            expired.push(key.clone());
+            continue;
+        }
+        if key == concrete_selector {
+            continue;
+        }
+        if !key.contains('{') && !key.contains(':') {
+            continue;
+        }
+        let space_idx = match key.find(' ') {
+            Some(i) => i,
+            None => continue,
+        };
+        if &key[..space_idx] != method {
+            continue;
+        }
+        if path_matches_pattern(concrete_path, &key[space_idx + 1..]) {
+            all_by.extend(entry.by.iter().cloned());
+        }
+    }
+    for key in expired {
+        delete_locked(s, &key);
+    }
+    let mut deduped: Vec<String> = Vec::with_capacity(all_by.len());
+    for src in all_by {
+        if !deduped.iter().any(|d| d == &src) {
+            deduped.push(src);
+        }
+    }
+    let any = !deduped.is_empty();
+    (deduped, any)
+}
+
+fn enforce_capacity_locked(s: &mut TrackerState, max_entries: usize) {
+    if s.entries.len() <= max_entries {
+        return;
+    }
+    let now = Instant::now();
+    let expired: Vec<String> = s
+        .entries
+        .iter()
+        .filter(|(_, e)| e.until <= now)
+        .map(|(k, _)| k.clone())
+        .collect();
+    for key in expired {
+        delete_locked(s, &key);
+    }
+    let target = if max_entries / 2 < 1 { 1 } else { max_entries / 2 };
+    while s.entries.len() > target && !s.order.is_empty() {
+        let oldest = s.order[0].clone();
+        delete_locked(s, &oldest);
+    }
+}