@lovrozagar/honey 0.7.2 → 1.0.0-rc.1

package/dist/client-rust/runtime_sync.rs

@@ -1,484 +0,0 @@
-/* Code generated by honey. DO NOT EDIT. */
-
-#![allow(dead_code)]
-
-/* WARNING: reqwest::blocking::Client WILL deadlock if called from inside a tokio async task.
-   Only use SyncClient and do_request_blocking from non-async contexts (e.g. plain threads,
-   test harnesses, CLI tools). Never call blocking methods from within an async runtime. */
-
-use crate::errors::{raise_for_status, Error};
-use crate::runtime::{build_url, encode_query, merged_headers, set_header, LogEntry, OnLogHook};
-use std::collections::HashMap;
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::{Arc, Mutex};
-use std::time::Duration;
-
-/// SyncOnRequestHook is a synchronous (non-async) request hook.
-/// Returns Result<(), Error> directly — no Future, no Pin<Box<...>>.
-pub type SyncOnRequestHook =
-    Arc<dyn Fn(&mut SyncRequestContext) -> Result<(), Error> + Send + Sync>;
-
-/// SyncOnResponseHook is a synchronous (non-async) response hook.
-pub type SyncOnResponseHook =
-    Arc<dyn Fn(&mut SyncResponseContext) -> Result<(), Error> + Send + Sync>;
-
-/// SyncRequestContext carries mutable request metadata through SyncOnRequestHook invocations.
-/// `selector` / `is_stale` / `invalidated_by` mirror the async RequestContext fields.
-pub struct SyncRequestContext {
-    pub method: reqwest::Method,
-    pub url: String,
-    pub path: String,
-    pub headers: HashMap<String, String>,
-    /// `SyncClientConfig::state`, shared by every hook of every call; a fresh map per call when unset.
-    pub state: Arc<std::sync::Mutex<HashMap<String, serde_json::Value>>>,
-    pub is_retry: bool,
-    pub selector: String,
-    pub is_stale: bool,
-    pub invalidated_by: Vec<String>,
-}
-
-/// SyncResponseContext carries response metadata through SyncOnResponseHook invocations.
-pub struct SyncResponseContext {
-    pub status: u16,
-    pub response: Vec<u8>,
-    pub headers: reqwest::header::HeaderMap,
-    /// The same map the request hooks saw.
-    pub state: Arc<std::sync::Mutex<HashMap<String, serde_json::Value>>>,
-    pub is_retry: bool,
-    pub selector: String,
-    pub is_stale: bool,
-    pub invalidated_by: Vec<String>,
-}
-
-/// SyncRequestBody represents the different body types a blocking request can carry.
-/// `Multipart` and `Stream` own single-shot bodies and are not retried on 401.
-pub enum SyncRequestBody<'a> {
-    None,
-    Json(&'a serde_json::Value),
-    FormUrl(Vec<(String, String)>),
-    Raw(&'static str, bytes::Bytes),
-    Multipart(reqwest::blocking::multipart::Form),
-    Stream(reqwest::blocking::Body),
-}
-
-/// SyncClientConfig holds all configuration for the blocking SDK client.
-/// Same semantics as [`crate::runtime::ClientConfig`].
-#[derive(Clone)]
-pub struct SyncClientConfig {
-    pub base_url: String,
-    pub bearer_token: Option<String>,
-    pub headers: HashMap<String, String>,
-    pub timeout: Duration,
-    /// Ignored at runtime: whether methods return `SdkResult` is fixed when the SDK is generated.
-    #[deprecated(note = "has no effect; generate with `throwOnError: false` for SdkResult methods")]
-    pub throw_on_error: bool,
-    /// Fallback for `InvalidationConfig::stale_max_entries` when that is 0.
-    pub stale_max_entries: usize,
-    pub invalidation: Option<crate::runtime::InvalidationConfig>,
-    /// Returns the new token; an empty string means "give up".
-    pub on_auth_expired:
-        Option<Arc<dyn Fn() -> Result<String, Error> + Send + Sync>>,
-    pub http_client: Option<reqwest::blocking::Client>,
-    pub auth_header_name: Option<String>,
-    pub auth_header_prefix: Option<String>,
-    pub on_request: Vec<SyncOnRequestHook>,
-    pub on_response: Vec<SyncOnResponseHook>,
-    pub on_log: Option<OnLogHook>,
-    /// Shared state handed to every `on_request` / `on_response` hook (`ctx.state`).
-    pub state: Option<Arc<std::sync::Mutex<HashMap<String, serde_json::Value>>>>,
-    pub max_response_bytes: usize,
-}
-
-#[allow(deprecated)]
-impl Default for SyncClientConfig {
-    fn default() -> Self {
-        SyncClientConfig {
-            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,
-            max_response_bytes: crate::runtime::DEFAULT_MAX_RESPONSE_BYTES,
-        }
-    }
-}
-
-/// SyncAuthState is the blocking twin of [`crate::runtime::AuthState`].
-pub struct SyncAuthState {
-    token: Mutex<Option<String>>,
-}
-
-impl SyncAuthState {
-    pub fn new(token: Option<String>) -> Self {
-        SyncAuthState { token: Mutex::new(token) }
-    }
-
-    pub fn current(&self) -> Option<String> {
-        self.token.lock().unwrap_or_else(|p| p.into_inner()).clone()
-    }
-
-    fn refresh(
-        &self,
-        hook: &Arc<dyn Fn() -> Result<String, Error> + Send + Sync>,
-        rejected: Option<&str>,
-    ) -> Result<Option<String>, Error> {
-        let mut guard = self.token.lock().unwrap_or_else(|p| p.into_inner());
-        if guard.as_deref() != rejected {
-            return Ok(guard.clone());
-        }
-        let token = hook().map_err(|e| Error::AuthExpired(e.to_string()))?;
-        if token.is_empty() {
-            return Ok(None);
-        }
-        *guard = Some(token.clone());
-        Ok(Some(token))
-    }
-}
-
-/// default_http_client_blocking follows redirects on the same origin only.
-pub fn default_http_client_blocking() -> reqwest::blocking::Client {
-    reqwest::blocking::Client::builder()
-        .redirect(crate::runtime::same_host_redirects())
-        .build()
-        .unwrap_or_default()
-}
-
-/* emit_log invokes the on_log callback if configured, swallowing any panic so a
-   faulty logger cannot break the request path. Mirrors runtime.rs sibling. */
-fn emit_log(cfg: &SyncClientConfig, 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. */
-fn err_status(err: &Error) -> Option<i32> {
-    if let Error::Api(api) = err {
-        Some(api.status() as i32)
-    } else {
-        None
-    }
-}
-
-fn map_err(e: reqwest::Error) -> Error {
-    if e.is_timeout() {
-        Error::Timeout
-    } else {
-        Error::Transport(e)
-    }
-}
-
-/// SyncRequestResult carries the raw bytes, status, headers, and final URL from a blocking request.
-#[allow(dead_code)]
-pub(crate) struct SyncRequestResult {
-    pub body: Vec<u8>,
-    pub status: u16,
-    pub headers: reqwest::header::HeaderMap,
-    pub url: String,
-}
-
-/// do_request_blocking executes a blocking 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,
-/// response_received once for the final response, error on terminal failure).
-#[allow(clippy::too_many_arguments)]
-pub(crate) fn do_request_blocking(
-    client: &reqwest::blocking::Client,
-    cfg: &SyncClientConfig,
-    auth: &SyncAuthState,
-    method: reqwest::Method,
-    raw_url: &str,
-    query: &[(String, String)],
-    body: SyncRequestBody<'_>,
-    call_headers: Option<&HashMap<String, String>>,
-    timeout: Option<Duration>,
-    cancel_token: Option<Arc<AtomicBool>>,
-    operation: &str,
-    request_meta: Option<&crate::invalidation::RequestMeta>,
-) -> Result<SyncRequestResult, Error> {
-    let start = std::time::Instant::now();
-    let log_error = |e: &Error| {
-        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)),
-            },
-        )
-    };
-
-    /* Pre-flight cancellation check — short-circuit before any work. Blocking
-       sends cannot be interrupted once started. */
-    if let Some(ref tok) = cancel_token {
-        if tok.load(Ordering::Acquire) {
-            log_error(&Error::Canceled);
-            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,
-        },
-    );
-
-    let retry_body: Option<SyncRequestBody<'_>> = match &body {
-        SyncRequestBody::None => Some(SyncRequestBody::None),
-        SyncRequestBody::Json(v) => Some(SyncRequestBody::Json(v)),
-        SyncRequestBody::FormUrl(m) => Some(SyncRequestBody::FormUrl(m.clone())),
-        SyncRequestBody::Raw(ct, b) => Some(SyncRequestBody::Raw(ct, b.clone())),
-        SyncRequestBody::Multipart(_) => None,
-        SyncRequestBody::Stream(_) => None,
-    };
-
-    let token = auth.current();
-    let mut result = match execute_request_blocking(
-        client,
-        cfg,
-        method.clone(),
-        raw_url,
-        query,
-        body,
-        call_headers,
-        token.as_deref(),
-        false,
-        timeout,
-        cancel_token.clone(),
-        request_meta,
-    ) {
-        Ok(r) => r,
-        Err(e) => {
-            log_error(&e);
-            return Err(e);
-        }
-    };
-
-    if result.status == 401 {
-        if let (Some(hook), Some(retry)) = (cfg.on_auth_expired.as_ref(), retry_body) {
-            let new_token = match auth.refresh(hook, token.as_deref()) {
-                Ok(t) => t,
-                Err(e) => {
-                    log_error(&e);
-                    return Err(e);
-                }
-            };
-            if let Some(new_token) = new_token {
-                result = match execute_request_blocking(
-                    client,
-                    cfg,
-                    method,
-                    raw_url,
-                    query,
-                    retry,
-                    call_headers,
-                    Some(&new_token),
-                    true,
-                    timeout,
-                    cancel_token,
-                    request_meta,
-                ) {
-                    Ok(r) => r,
-                    Err(e) => {
-                        log_error(&e);
-                        return Err(e);
-                    }
-                };
-            }
-        }
-    }
-
-    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 !(200..300).contains(&result.status) {
-        if let Some(err) = raise_for_status(result.status, std::mem::take(&mut result.body)) {
-            log_error(&err);
-            return Err(err);
-        }
-    }
-
-    Ok(result)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn execute_request_blocking(
-    client: &reqwest::blocking::Client,
-    cfg: &SyncClientConfig,
-    method: reqwest::Method,
-    raw_url: &str,
-    query: &[(String, String)],
-    body: SyncRequestBody<'_>,
-    call_headers: Option<&HashMap<String, String>>,
-    bearer_token: Option<&str>,
-    is_retry: bool,
-    per_call_timeout: Option<Duration>,
-    cancel_token: Option<Arc<AtomicBool>>,
-    request_meta: Option<&crate::invalidation::RequestMeta>,
-) -> Result<SyncRequestResult, Error> {
-    let url = build_url(&cfg.base_url, raw_url, query)?;
-
-    let mut hook_headers = merged_headers(
-        &cfg.headers,
-        call_headers,
-        cfg.auth_header_name.as_deref(),
-        cfg.auth_header_prefix.as_deref(),
-        bearer_token,
-    );
-    match &body {
-        SyncRequestBody::Json(_) => set_header(&mut hook_headers, "Content-Type", "application/json".into()),
-        SyncRequestBody::FormUrl(_) => set_header(
-            &mut hook_headers,
-            "Content-Type",
-            "application/x-www-form-urlencoded".into(),
-        ),
-        SyncRequestBody::Raw(ct, _) => set_header(&mut hook_headers, "Content-Type", ct.to_string()),
-        SyncRequestBody::Stream(_) => {
-            if !hook_headers.keys().any(|k| k.eq_ignore_ascii_case("content-type")) {
-                set_header(&mut hook_headers, "Content-Type", "application/octet-stream".into());
-            }
-        }
-        SyncRequestBody::Multipart(_) | SyncRequestBody::None => {}
-    }
-
-    let state = cfg
-        .state
-        .clone()
-        .unwrap_or_else(|| Arc::new(std::sync::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 = SyncRequestContext {
-        method: method.clone(),
-        url: url.to_string(),
-        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(),
-    };
-
-    for hook in cfg.on_request.iter() {
-        hook(&mut req_ctx)?;
-    }
-
-    let mut req = client.request(req_ctx.method.clone(), &req_ctx.url);
-    for (k, v) in &req_ctx.headers {
-        req = req.header(k.as_str(), v.as_str());
-    }
-    req = match body {
-        SyncRequestBody::Json(v) => req.body(serde_json::to_vec(v)?),
-        SyncRequestBody::FormUrl(pairs) => req.body(encode_query(&pairs)),
-        SyncRequestBody::Raw(_, b) => req.body(b.to_vec()),
-        SyncRequestBody::Multipart(f) => req.multipart(f),
-        SyncRequestBody::Stream(b) => req.body(b),
-        SyncRequestBody::None => req,
-    };
-
-    /* per-call timeout overrides cfg.timeout; ZERO means no timeout */
-    let effective_timeout = per_call_timeout.unwrap_or(cfg.timeout);
-    if !effective_timeout.is_zero() {
-        req = req.timeout(effective_timeout);
-    }
-
-    if let Some(ref tok) = cancel_token {
-        if tok.load(Ordering::Acquire) {
-            return Err(Error::Canceled);
-        }
-    }
-
-    let mut resp = req.send().map_err(map_err)?;
-
-    let status = resp.status().as_u16();
-    let resp_headers = resp.headers().clone();
-    let resp_url = resp.url().to_string();
-    let mut body_bytes = Vec::new();
-    let limit = cfg.max_response_bytes;
-    {
-        use std::io::Read;
-        let mut buf = [0u8; 16 * 1024];
-        loop {
-            let n = resp.read(&mut buf).map_err(|e| {
-                if e.kind() == std::io::ErrorKind::TimedOut {
-                    Error::Timeout
-                } else {
-                    Error::Other(e.to_string())
-                }
-            })?;
-            if n == 0 {
-                break;
-            }
-            if limit > 0 && body_bytes.len() + n > limit {
-                return Err(Error::Other(format!("response body exceeds {} bytes", limit)));
-            }
-            body_bytes.extend_from_slice(&buf[..n]);
-        }
-    }
-
-    let mut resp_ctx = SyncResponseContext {
-        status,
-        response: body_bytes,
-        headers: resp_headers,
-        state,
-        is_retry,
-        selector: meta_selector,
-        is_stale: meta_is_stale,
-        invalidated_by: meta_by,
-    };
-
-    for hook in cfg.on_response.iter() {
-        hook(&mut resp_ctx)?;
-    }
-
-    Ok(SyncRequestResult {
-        body: resp_ctx.response,
-        status,
-        headers: resp_ctx.headers,
-        url: resp_url,
-    })
-}
-
-/// build_url_sync constructs the full URL from base + path + query params.
-pub(crate) fn build_url_sync(
-    base_url: &str,
-    path: &str,
-    query: &[(String, String)],
-) -> Result<url::Url, Error> {
-    build_url(base_url, path, query)
-}

package/dist/client-rust/sse.rs

@@ -1,188 +0,0 @@
-/* Code generated by honey. DO NOT EDIT. */
-
-use crate::errors::{raise_for_status, Error};
-use futures_util::StreamExt;
-
-/// SseEvent represents a single server-sent event. `id` is the last event id
-/// seen on the stream so far (the spec's sticky "last event ID buffer").
-#[derive(Debug, Clone, Default, PartialEq)]
-pub struct SseEvent {
-    pub data: String,
-    pub event: String,
-    pub id: String,
-    pub retry: i32,
-}
-
-/// Largest single line, and largest data of one event.
-pub const SSE_MAX_LINE: usize = 1024 * 1024;
-pub const SSE_MAX_EVENT: usize = 8 * 1024 * 1024;
-
-/// SseParser is an incremental WHATWG event-stream parser. Lines end in CRLF,
-/// LF or CR; a blank line dispatches; a final event without its blank line is
-/// never dispatched; `id` is sticky; `retry` needs ASCII digits; field values
-/// are not trimmed. Each input byte is scanned once.
-#[derive(Debug, Default)]
-pub struct SseParser {
-    line: Vec<u8>,
-    pending_cr: bool,
-    started: bool,
-    data: String,
-    has_data: bool,
-    event: String,
-    last_id: String,
-    retry: i32,
-}
-
-impl SseParser {
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    /// feed consumes a chunk and returns every event it completes.
-    pub fn feed(&mut self, chunk: &[u8]) -> Result<Vec<SseEvent>, Error> {
-        let mut out = Vec::new();
-        for &b in chunk {
-            if self.pending_cr {
-                self.pending_cr = false;
-                if b == b'\n' {
-                    continue;
-                }
-            }
-            match b {
-                b'\n' | b'\r' => {
-                    if b == b'\r' {
-                        self.pending_cr = true;
-                    }
-                    let line = std::mem::take(&mut self.line);
-                    if let Some(ev) = self.process(&line)? {
-                        out.push(ev);
-                    }
-                }
-                _ => {
-                    if self.line.len() >= SSE_MAX_LINE {
-                        return Err(Error::Other("sse line exceeds 1 MiB".into()));
-                    }
-                    self.line.push(b);
-                }
-            }
-        }
-        Ok(out)
-    }
-
-    fn process(&mut self, raw: &[u8]) -> Result<Option<SseEvent>, Error> {
-        let mut line = String::from_utf8_lossy(raw).into_owned();
-        if !self.started {
-            self.started = true;
-            if let Some(rest) = line.strip_prefix('\u{feff}') {
-                line = rest.to_string();
-            }
-        }
-        if line.is_empty() {
-            return Ok(self.dispatch());
-        }
-        if line.starts_with(':') {
-            return Ok(None);
-        }
-        let (field, value) = match line.find(':') {
-            Some(i) => {
-                let v = &line[i + 1..];
-                (&line[..i], v.strip_prefix(' ').unwrap_or(v))
-            }
-            None => (line.as_str(), ""),
-        };
-        match field {
-            "data" => {
-                if self.has_data {
-                    self.data.push('\n');
-                }
-                if self.data.len() + value.len() > SSE_MAX_EVENT {
-                    return Err(Error::Other("sse event exceeds 8 MiB".into()));
-                }
-                self.data.push_str(value);
-                self.has_data = true;
-            }
-            "event" => self.event = value.to_string(),
-            "id" => {
-                if !value.contains('\0') {
-                    self.last_id = value.to_string();
-                }
-            }
-            "retry" => {
-                if !value.is_empty() && value.bytes().all(|c| c.is_ascii_digit()) {
-                    if let Ok(n) = value.parse::<i32>() {
-                        self.retry = n;
-                    }
-                }
-            }
-            _ => {}
-        }
-        Ok(None)
-    }
-
-    fn dispatch(&mut self) -> Option<SseEvent> {
-        let ev = if self.has_data {
-            Some(SseEvent {
-                data: std::mem::take(&mut self.data),
-                event: std::mem::take(&mut self.event),
-                id: self.last_id.clone(),
-                retry: self.retry,
-            })
-        } else {
-            None
-        };
-        self.data.clear();
-        self.has_data = false;
-        self.event.clear();
-        self.retry = 0;
-        ev
-    }
-}
-
-/// parse_sse_text parses complete text; used by the conformance vectors.
-pub fn parse_sse_text(chunks: &[&str]) -> Result<Vec<SseEvent>, Error> {
-    let mut p = SseParser::new();
-    let mut out = Vec::new();
-    for c in chunks {
-        out.extend(p.feed(c.as_bytes())?);
-    }
-    Ok(out)
-}
-
-/// parse_sse_stream returns a Stream of SseEvent values read from a reqwest Response.
-/// On non-2xx response it yields a typed error immediately then terminates.
-pub fn parse_sse_stream(
-    resp: reqwest::Response,
-) -> impl futures_util::Stream<Item = Result<SseEvent, Error>> {
-    async_stream::stream! {
-        let status = resp.status().as_u16();
-        if !(200..300).contains(&status) {
-            let body = resp.bytes().await.unwrap_or_default().to_vec();
-            if let Some(err) = raise_for_status(status, body) {
-                yield Err(err);
-            }
-            return;
-        }
-
-        let mut byte_stream = resp.bytes_stream();
-        let mut parser = SseParser::new();
-        while let Some(chunk) = byte_stream.next().await {
-            match chunk {
-                Err(e) => {
-                    yield Err(Error::Transport(e));
-                    return;
-                }
-                Ok(bytes) => match parser.feed(&bytes) {
-                    Ok(events) => {
-                        for ev in events {
-                            yield Ok(ev);
-                        }
-                    }
-                    Err(e) => {
-                        yield Err(e);
-                        return;
-                    }
-                },
-            }
-        }
-    }
-}