@lovrozagar/honey 0.1.0

package/src/client-rust/result.rs

@@ -0,0 +1,22 @@
+/* Code generated by honey. DO NOT EDIT. */
+
+use crate::errors::Error;
+
+/// SdkResult is a generic result container for safe-mode SDK calls (throwOnError=false).
+/// In safe mode, methods return SdkResult<T> instead of T.
+/// The error is embedded in the result — the outer Result retains only transport/parse errors.
+/// E defaults to Error (generic transport/api error) but per-op typed error envelopes
+/// can substitute a narrower type (e.g. SdkResult<User, UsersCreateError>).
+pub struct SdkResult<T, E = Error> {
+    pub data: Option<T>,
+    pub error: Option<E>,
+    pub status: u16,
+    pub response: crate::runtime::ResponseMeta,
+}
+
+impl<T, E> SdkResult<T, E> {
+    /// ok returns true when the result carries no error.
+    pub fn ok(&self) -> bool {
+        self.error.is_none()
+    }
+}

package/src/client-rust/runtime.rs

@@ -0,0 +1,547 @@
+/* Code generated by honey. DO NOT EDIT. */
+
+#![allow(dead_code)]
+
+use crate::errors::{raise_for_status, Error};
+use std::collections::HashMap;
+use std::future::Future;
+use std::pin::Pin;
+use std::sync::Arc;
+use std::time::Duration;
+use tokio::sync::Mutex;
+use tokio_util::sync::CancellationToken;
+
+/// OnRequestHook is called before each request is sent.
+/// Receives a mutable RequestContext; can mutate headers, url, or body.
+/// Returning Err short-circuits the request.
+pub type OnRequestHook = Arc<
+    dyn Fn(
+            &mut RequestContext,
+        ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + '_>>
+        + Send
+        + Sync,
+>;
+
+/// OnResponseHook is called after each response is received (before error mapping).
+pub type OnResponseHook = Arc<
+    dyn Fn(
+            &mut ResponseContext,
+        ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + '_>>
+        + Send
+        + Sync,
+>;
+
+/// RequestContext carries mutable request metadata through OnRequestHook invocations.
+/// `selector` / `is_stale` / `invalidated_by` mirror the TS hook ctx and are
+/// populated from the RequestMeta snapshot taken before the request fires;
+/// zero values when the tracker is disabled.
+pub struct RequestContext {
+    pub method: reqwest::Method,
+    pub url: String,
+    pub path: String,
+    pub headers: HashMap<String, String>,
+    pub state: Arc<Mutex<HashMap<String, serde_json::Value>>>,
+    pub is_retry: bool,
+    pub selector: String,
+    pub is_stale: bool,
+    pub invalidated_by: Vec<String>,
+}
+
+/// ResponseContext carries response metadata through OnResponseHook invocations.
+/// `selector` / `is_stale` / `invalidated_by` mirror the RequestContext fields.
+pub struct ResponseContext {
+    pub status: u16,
+    pub response: Vec<u8>,
+    pub headers: reqwest::header::HeaderMap,
+    pub state: Arc<Mutex<HashMap<String, serde_json::Value>>>,
+    pub is_retry: bool,
+    pub selector: String,
+    pub is_stale: bool,
+    pub invalidated_by: Vec<String>,
+}
+
+/// RequestBody represents the different body types a request can carry.
+/// `Stream` carries an owned, single-shot `reqwest::Body` (typically built via
+/// `reqwest::Body::wrap_stream`); like `Multipart`, it cannot be retried on 401
+/// because the underlying body is not `Clone`.
+pub enum RequestBody<'a> {
+    None,
+    Json(&'a serde_json::Value),
+    FormUrl(&'a HashMap<String, String>),
+    Multipart(reqwest::multipart::Form),
+    Stream(reqwest::Body),
+}
+
+/// OnAuthExpiredHook is the async auth-refresh callback type for ClientConfig.
+pub type OnAuthExpiredHook =
+    Arc<dyn Fn() -> Pin<Box<dyn Future<Output = Result<String, Error>> + Send>> + Send + Sync>;
+
+/// LogEntry is the payload passed to on_log callbacks. Consumers plug in their
+/// own logger; the SDK never formats, levels, or persists. Status is Option so
+/// None encodes "omitted" (request_start) without colliding with a real 0 status.
+/// error is repr-style String on the "error" event; None otherwise. Field layout
+/// matches the TS/Python/Go LogEntry shape for cross-language consumer parity.
+#[derive(Clone, Debug)]
+pub struct LogEntry {
+    pub level: String,
+    pub event: String,
+    pub operation: String,
+    pub duration_ms: i64,
+    pub status: Option<i32>,
+    pub error: Option<String>,
+}
+
+/// OnLogHook is the callback type for lifecycle log events. Shared between
+/// ClientConfig (async) and SyncClientConfig (blocking) — both take the same
+/// synchronous Fn signature (emission is fire-and-forget from either runtime).
+pub type OnLogHook = Arc<dyn Fn(LogEntry) + Send + Sync>;
+
+/// ClientConfig holds all configuration for the SDK client.
+#[derive(Clone)]
+pub struct ClientConfig {
+    pub base_url: String,
+    pub bearer_token: Option<String>,
+    pub headers: HashMap<String, String>,
+    pub timeout: Duration,
+    pub throw_on_error: bool,
+    pub stale_max_entries: usize,
+    pub invalidation: Option<InvalidationConfig>,
+    pub on_auth_expired: Option<OnAuthExpiredHook>,
+    pub http_client: Option<reqwest::Client>,
+    pub auth_header_name: Option<String>,
+    pub auth_header_prefix: Option<String>,
+    pub on_request: Vec<OnRequestHook>,
+    pub on_response: Vec<OnResponseHook>,
+    pub on_log: Option<OnLogHook>,
+    pub state: Option<Arc<Mutex<HashMap<String, serde_json::Value>>>>,
+}
+
+impl Default for ClientConfig {
+    fn default() -> Self {
+        ClientConfig {
+            base_url: String::new(),
+            bearer_token: None,
+            headers: HashMap::new(),
+            timeout: Duration::from_secs(30),
+            throw_on_error: true,
+            stale_max_entries: 500,
+            invalidation: None,
+            on_auth_expired: None,
+            http_client: None,
+            auth_header_name: None,
+            auth_header_prefix: None,
+            on_request: Vec::new(),
+            on_response: Vec::new(),
+            on_log: None,
+            state: None,
+        }
+    }
+}
+
+/* emit_log invokes the on_log callback if configured, swallowing any panic so a
+   faulty logger cannot break the request path. Mirrors Python try/except and Go
+   defer recover. */
+fn emit_log(cfg: &ClientConfig, entry: LogEntry) {
+    if let Some(ref hook) = cfg.on_log {
+        let h = Arc::clone(hook);
+        let _ = std::panic::catch_unwind(std::panic::AssertUnwindSafe(move || h(entry)));
+    }
+}
+
+/* err_status extracts an HTTP status from a typed Error::Api, returning None for
+   non-Api errors (Transport/Json/UrlParse/Canceled/Timeout/AuthExpired/Other). */
+fn err_status(err: &Error) -> Option<i32> {
+    if let Error::Api(api) = err {
+        Some(api.status() as i32)
+    } else {
+        None
+    }
+}
+
+/// InvalidationConfig controls cache invalidation behaviour. `stale_time` is in
+/// milliseconds; ≤0 disables the tracker. `stale_max_entries` caps the LRU map
+/// (default 1000 when 0). `max_sources_per_target` caps the `by` list per stale
+/// entry (default 16 when 0).
+#[derive(Clone, Default)]
+pub struct InvalidationConfig {
+    pub stale_time: i64,
+    pub stale_max_entries: usize,
+    pub max_sources_per_target: usize,
+}
+
+/// ResponseMeta is the owned response snapshot embedded in SdkResult.response.
+/// Populated from a completed RequestResult; all fields are Clone-able.
+pub struct ResponseMeta {
+    pub status: u16,
+    pub headers: reqwest::header::HeaderMap,
+    pub url: String,
+    pub body: Vec<u8>,
+}
+
+/// RequestResult carries the raw bytes, status, headers, and final URL from a completed request.
+#[allow(dead_code)]
+pub(crate) struct RequestResult {
+    pub body: Vec<u8>,
+    pub status: u16,
+    pub headers: reqwest::header::HeaderMap,
+    pub url: String,
+}
+
+/// do_request executes an HTTP request, injects auth, merges headers, handles
+/// on_auth_expired retry on 401, fires on_request/on_response hooks, and wraps
+/// errors into typed Error variants. Emits on_log lifecycle entries (request_start
+/// once at entry, response_received once for the final response, error on terminal
+/// failure) — matching TS/Python/Go behavior where retry rounds do not double-emit.
+#[allow(clippy::too_many_arguments)]
+pub(crate) async fn do_request(
+    client: &reqwest::Client,
+    cfg: &ClientConfig,
+    method: reqwest::Method,
+    raw_url: &str,
+    query: &[(String, String)],
+    body: RequestBody<'_>,
+    call_headers: Option<&HashMap<String, String>>,
+    timeout: Option<std::time::Duration>,
+    cancel_token: Option<CancellationToken>,
+    operation: &str,
+    request_meta: Option<&crate::invalidation::RequestMeta>,
+) -> Result<RequestResult, Error> {
+    let start = std::time::Instant::now();
+
+    /* Pre-flight cancellation check — short-circuit before any work. */
+    if let Some(ref tok) = cancel_token {
+        if tok.is_cancelled() {
+            emit_log(
+                cfg,
+                LogEntry {
+                    level: "error".to_string(),
+                    event: "error".to_string(),
+                    operation: operation.to_string(),
+                    duration_ms: start.elapsed().as_millis() as i64,
+                    status: None,
+                    error: Some("Canceled".to_string()),
+                },
+            );
+            return Err(Error::Canceled);
+        }
+    }
+
+    emit_log(
+        cfg,
+        LogEntry {
+            level: "debug".to_string(),
+            event: "request_start".to_string(),
+            operation: operation.to_string(),
+            duration_ms: 0,
+            status: None,
+            error: None,
+        },
+    );
+
+    /* Reborrow body for retry path (Json/FormUrl hold references so reborrow is valid;
+       Multipart + Stream own non-Clone values and cannot be retried — 401 falls through) */
+    let retry_body: Option<RequestBody<'_>> = match &body {
+        RequestBody::None => Some(RequestBody::None),
+        RequestBody::Json(v) => Some(RequestBody::Json(v)),
+        RequestBody::FormUrl(m) => Some(RequestBody::FormUrl(m)),
+        RequestBody::Multipart(_) => None,
+        RequestBody::Stream(_) => None,
+    };
+
+    let mut result = match execute_request(
+        client,
+        cfg,
+        method.clone(),
+        raw_url,
+        query,
+        body,
+        call_headers,
+        cfg.bearer_token.as_deref(),
+        false,
+        timeout,
+        cancel_token.clone(),
+        request_meta,
+    )
+    .await
+    {
+        Ok(r) => r,
+        Err(e) => {
+            emit_log(
+                cfg,
+                LogEntry {
+                    level: "error".to_string(),
+                    event: "error".to_string(),
+                    operation: operation.to_string(),
+                    duration_ms: start.elapsed().as_millis() as i64,
+                    status: err_status(&e),
+                    error: Some(format!("{:?}", e)),
+                },
+            );
+            return Err(e);
+        }
+    };
+
+    if result.status == 401 {
+        if let Some(ref hook) = cfg.on_auth_expired {
+            if let Some(retry) = retry_body {
+                let new_token = match hook().await {
+                    Ok(t) => t,
+                    Err(e) => {
+                        let mapped = Error::AuthExpired(e.to_string());
+                        emit_log(
+                            cfg,
+                            LogEntry {
+                                level: "error".to_string(),
+                                event: "error".to_string(),
+                                operation: operation.to_string(),
+                                duration_ms: start.elapsed().as_millis() as i64,
+                                status: err_status(&mapped),
+                                error: Some(format!("{:?}", mapped)),
+                            },
+                        );
+                        return Err(mapped);
+                    }
+                };
+                result = match execute_request(
+                    client,
+                    cfg,
+                    method,
+                    raw_url,
+                    query,
+                    retry,
+                    call_headers,
+                    Some(&new_token),
+                    true,
+                    timeout,
+                    cancel_token,
+                    request_meta,
+                )
+                .await
+                {
+                    Ok(r) => r,
+                    Err(e) => {
+                        emit_log(
+                            cfg,
+                            LogEntry {
+                                level: "error".to_string(),
+                                event: "error".to_string(),
+                                operation: operation.to_string(),
+                                duration_ms: start.elapsed().as_millis() as i64,
+                                status: err_status(&e),
+                                error: Some(format!("{:?}", e)),
+                            },
+                        );
+                        return Err(e);
+                    }
+                };
+            }
+            /* Multipart/Stream 401: Form/Body is not Clone, cannot retry; fall through to error mapping */
+        }
+    }
+
+    let status_i32 = result.status as i32;
+    let level = if result.status >= 400 { "warn" } else { "info" };
+    emit_log(
+        cfg,
+        LogEntry {
+            level: level.to_string(),
+            event: "response_received".to_string(),
+            operation: operation.to_string(),
+            duration_ms: start.elapsed().as_millis() as i64,
+            status: Some(status_i32),
+            error: None,
+        },
+    );
+
+    if let Some(err) = raise_for_status(result.status, result.body.clone()) {
+        emit_log(
+            cfg,
+            LogEntry {
+                level: "error".to_string(),
+                event: "error".to_string(),
+                operation: operation.to_string(),
+                duration_ms: start.elapsed().as_millis() as i64,
+                status: Some(status_i32),
+                error: Some(format!("{:?}", err)),
+            },
+        );
+        return Err(err);
+    }
+
+    Ok(result)
+}
+
+#[allow(clippy::too_many_arguments)]
+async fn execute_request(
+    client: &reqwest::Client,
+    cfg: &ClientConfig,
+    method: reqwest::Method,
+    raw_url: &str,
+    query: &[(String, String)],
+    body: RequestBody<'_>,
+    call_headers: Option<&HashMap<String, String>>,
+    bearer_token: Option<&str>,
+    is_retry: bool,
+    per_call_timeout: Option<std::time::Duration>,
+    cancel_token: Option<CancellationToken>,
+    request_meta: Option<&crate::invalidation::RequestMeta>,
+) -> Result<RequestResult, Error> {
+    let url = build_url(&cfg.base_url, raw_url, query)?;
+    let url_str = url.to_string();
+
+    /* build merged headers map for hook inspection */
+    let mut hook_headers: HashMap<String, String> = cfg.headers.clone();
+    if let Some(ch) = call_headers {
+        for (k, v) in ch {
+            hook_headers.insert(k.clone(), v.clone());
+        }
+    }
+    if let Some(token) = bearer_token {
+        if !token.is_empty() {
+            let name = cfg.auth_header_name.as_deref().unwrap_or("Authorization");
+            let prefix = cfg.auth_header_prefix.as_deref().unwrap_or("Bearer ");
+            hook_headers.insert(name.to_string(), format!("{}{}", prefix, token));
+        }
+    }
+
+    let state = cfg
+        .state
+        .clone()
+        .unwrap_or_else(|| Arc::new(Mutex::new(HashMap::new())));
+
+    let (meta_selector, meta_is_stale, meta_by) = match request_meta {
+        Some(m) => (m.selector.clone(), m.is_stale, m.invalidated_by.clone()),
+        None => (String::new(), false, Vec::new()),
+    };
+
+    let mut req_ctx = RequestContext {
+        method: method.clone(),
+        url: url_str.clone(),
+        path: raw_url.to_string(),
+        headers: hook_headers,
+        state: Arc::clone(&state),
+        is_retry,
+        selector: meta_selector.clone(),
+        is_stale: meta_is_stale,
+        invalidated_by: meta_by.clone(),
+    };
+
+    /* fire on_request hooks */
+    for hook in cfg.on_request.iter() {
+        hook(&mut req_ctx).await?;
+    }
+
+    let mut req = client.request(req_ctx.method.clone(), &req_ctx.url);
+
+    /* apply headers from context (already merged above + any hook mutations) */
+    for (k, v) in &req_ctx.headers {
+        req = req.header(k.as_str(), v.as_str());
+    }
+
+    /* apply body and content-type */
+    req = match body {
+        RequestBody::Json(v) => {
+            req = req.header("Content-Type", "application/json");
+            req.json(v)
+        }
+        RequestBody::FormUrl(m) => req.form(m),
+        RequestBody::Multipart(f) => req.multipart(f),
+        RequestBody::Stream(b) => {
+            req = req.header("Content-Type", "application/octet-stream");
+            req.body(b)
+        }
+        RequestBody::None => req,
+    };
+
+    /* apply per-call timeout (overrides cfg.timeout) */
+    let timeout = per_call_timeout;
+    let effective_timeout = timeout.unwrap_or(cfg.timeout);
+    req = req.timeout(effective_timeout);
+
+    /* Race the send future against cancel_token.cancelled() so external cancellation
+       takes priority over an in-flight HTTP send. */
+    let resp = match cancel_token.clone() {
+        Some(tok) => {
+            tokio::select! {
+                biased;
+                _ = tok.cancelled() => return Err(Error::Canceled),
+                r = req.send() => r,
+            }
+        }
+        None => req.send().await,
+    }
+    .map_err(|e| {
+        if e.is_timeout() {
+            Error::Timeout
+        } else if e.is_request() {
+            Error::Canceled
+        } else {
+            Error::Transport(e)
+        }
+    })?;
+
+    let status = resp.status().as_u16();
+    let resp_headers = resp.headers().clone();
+    let resp_url = resp.url().to_string();
+    let bytes = match cancel_token {
+        Some(tok) => {
+            tokio::select! {
+                biased;
+                _ = tok.cancelled() => return Err(Error::Canceled),
+                r = resp.bytes() => r,
+            }
+        }
+        None => resp.bytes().await,
+    }
+    .map_err(|e| {
+        if e.is_timeout() {
+            Error::Timeout
+        } else {
+            Error::Transport(e)
+        }
+    })?;
+    let body_bytes = bytes.to_vec();
+
+    let mut resp_ctx = ResponseContext {
+        status,
+        response: body_bytes.clone(),
+        headers: resp_headers.clone(),
+        state: Arc::clone(&state),
+        is_retry,
+        selector: meta_selector,
+        is_stale: meta_is_stale,
+        invalidated_by: meta_by,
+    };
+
+    /* fire on_response hooks */
+    for hook in cfg.on_response.iter() {
+        hook(&mut resp_ctx).await?;
+    }
+
+    Ok(RequestResult {
+        body: body_bytes,
+        status,
+        headers: resp_headers,
+        url: resp_url,
+    })
+}
+
+/// build_url constructs the full URL from base + path + query params.
+#[allow(dead_code)]
+pub(crate) fn build_url(
+    base_url: &str,
+    path: &str,
+    query: &[(String, String)],
+) -> Result<url::Url, Error> {
+    let base = url::Url::parse(base_url)?;
+    let joined = base.join(path)?;
+    let mut url = joined;
+    if !query.is_empty() {
+        let mut pairs = url.query_pairs_mut();
+        for (k, v) in query {
+            pairs.append_pair(k, v);
+        }
+    }
+    Ok(url)
+}
+