@lovrozagar/honey 0.6.8 → 0.7.1

package/dist/client-rust/errors.rs

@@ -0,0 +1,220 @@
+/* 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 = error_message(&body, data.as_ref());
+    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))
+}
+
+/// error_message is the server's `message` field when the body is a JSON object
+/// carrying one, else the body text, with control characters dropped and capped
+/// at 512 characters.
+pub(crate) fn error_message(body: &[u8], data: Option<&serde_json::Value>) -> String {
+    let text = data
+        .and_then(|d| d.get("message"))
+        .and_then(|m| m.as_str())
+        .map(|s| s.to_string())
+        .unwrap_or_else(|| String::from_utf8_lossy(body).into_owned());
+    let mut out = String::new();
+    for (n, ch) in text.chars().filter(|c| !c.is_control()).enumerate() {
+        if n >= 512 {
+            out.push('…');
+            break;
+        }
+        out.push(ch);
+    }
+    out
+}

package/dist/client-rust/invalidation.rs

@@ -0,0 +1,412 @@
+/* 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::{BTreeMap, HashMap, HashSet};
+use std::time::{Duration, Instant};
+use tokio::sync::Mutex;
+
+/* PLACEHOLDER_RE matches `{name}` (any name without braces or slashes) and a
+ * `:name` segment; a colon inside a segment (`/ops/1:cancel`) is literal.
+ * Group 1: braced name; group 2: the `/` (or start) before a colon param; group 3: its name. */
+static PLACEHOLDER_RE: Lazy<Regex> =
+    Lazy::new(|| Regex::new(r"\{([^{}/]+)\}|(^|/):([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 caps in PLACEHOLDER_RE.captures_iter(pattern) {
+        let m = caps.get(0).unwrap();
+        /* keep the segment slash of a `:name` match literal */
+        let start = m.start() + caps.get(2).map(|p| p.len()).unwrap_or(0);
+        out.push_str(&regex::escape(&pattern[last..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 prefix = caps.get(2).map(|c| c.as_str()).unwrap_or_default();
+        let key = caps
+            .get(1)
+            .or_else(|| caps.get(3))
+            .map(|c| c.as_str())
+            .unwrap_or_default();
+        match params.get(key) {
+            Some(v) => {
+                out.push_str(prefix);
+                out.push_str(&crate::runtime::escape_segment(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.
+/// Entries without placeholders pass through; an entry whose placeholders cannot
+/// all be resolved stays a pattern, so it marks every instance stale (TS parity).
+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(_) => out.push(entry.clone()),
+        }
+    }
+    out
+}
+
+struct Slot {
+    entry: StaleEntry,
+    /* position in `order`; a touch moves the entry to a fresh tick */
+    tick: u64,
+}
+
+/// Stale state shared by the async and blocking trackers; each wraps it in its own mutex.
+/// Concrete keys are found by one map read; keys that still hold placeholders are also
+/// indexed per method, so a lookup scans only the patterns of its method. `order` keeps
+/// LRU order by tick, so touch and eviction are O(log n).
+#[derive(Default)]
+pub(crate) struct TrackerState {
+    entries: HashMap<String, Slot>,
+    order: BTreeMap<u64, String>,
+    patterns: HashMap<String, HashSet<String>>,
+    next_tick: u64,
+    pub(crate) seq: u64,
+}
+
+impl TrackerState {
+    fn tick(&mut self) -> u64 {
+        self.next_tick += 1;
+        self.next_tick
+    }
+
+    pub(crate) fn upsert(&mut self, key: &str, until: Instant, seq: u64, mutation_selector: &str, max_sources: usize) {
+        let tick = self.tick();
+        if let Some(slot) = self.entries.get_mut(key) {
+            slot.entry.until = until;
+            slot.entry.seq = seq;
+            if !mutation_selector.is_empty()
+                && slot.entry.by.len() < max_sources
+                && !slot.entry.by.iter().any(|b| b == mutation_selector)
+            {
+                slot.entry.by.push(mutation_selector.to_string());
+            }
+            let old = std::mem::replace(&mut slot.tick, tick);
+            self.order.remove(&old);
+            self.order.insert(tick, key.to_string());
+            return;
+        }
+        let by = if mutation_selector.is_empty() { Vec::new() } else { vec![mutation_selector.to_string()] };
+        self.entries.insert(key.to_string(), Slot { entry: StaleEntry { by, seq, until }, tick });
+        self.order.insert(tick, key.to_string());
+        if let Some((method, _)) = key.split_once(' ') {
+            if key_is_pattern(key) {
+                self.patterns.entry(method.to_string()).or_default().insert(key.to_string());
+            }
+        }
+    }
+
+    pub(crate) fn delete(&mut self, key: &str) {
+        let Some(slot) = self.entries.remove(key) else { return };
+        self.order.remove(&slot.tick);
+        if let Some((method, _)) = key.split_once(' ') {
+            if let Some(bucket) = self.patterns.get_mut(method) {
+                bucket.remove(key);
+                if bucket.is_empty() {
+                    self.patterns.remove(method);
+                }
+            }
+        }
+    }
+
+    pub(crate) fn seq_of(&self, key: &str) -> Option<u64> {
+        self.entries.get(key).map(|s| s.entry.seq)
+    }
+
+    pub(crate) fn lookup(&mut self, 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) = self.entries.get(concrete_selector) {
+            if exact.entry.until > now {
+                all_by.extend(exact.entry.by.iter().cloned());
+            } else {
+                exact_expired = true;
+            }
+        }
+        if exact_expired {
+            self.delete(concrete_selector);
+        }
+        let mut expired: Vec<String> = Vec::new();
+        if let Some(bucket) = self.patterns.get(method) {
+            for key in bucket {
+                let Some(slot) = self.entries.get(key) else { continue };
+                if slot.entry.until <= now {
+                    expired.push(key.clone());
+                    continue;
+                }
+                if key == concrete_selector {
+                    continue;
+                }
+                let pattern = key.split_once(' ').map(|(_, p)| p).unwrap_or("");
+                if path_matches_pattern(concrete_path, pattern) {
+                    all_by.extend(slot.entry.by.iter().cloned());
+                }
+            }
+        }
+        for key in expired {
+            self.delete(&key);
+        }
+        let mut seen = HashSet::new();
+        all_by.retain(|src| seen.insert(src.clone()));
+        let any = !all_by.is_empty();
+        (all_by, any)
+    }
+
+    pub(crate) fn clear(&mut self, concrete_selector: &str, concrete_path: &str, method: &str, seq_snapshot: u64) {
+        if self.seq_of(concrete_selector).is_some_and(|seq| seq <= seq_snapshot) {
+            self.delete(concrete_selector);
+        }
+        let to_delete: Vec<String> = self
+            .patterns
+            .get(method)
+            .map(|bucket| {
+                bucket
+                    .iter()
+                    .filter(|key| {
+                        self.seq_of(key).is_some_and(|seq| seq <= seq_snapshot)
+                            && path_matches_pattern(concrete_path, key.split_once(' ').map(|(_, p)| p).unwrap_or(""))
+                    })
+                    .cloned()
+                    .collect()
+            })
+            .unwrap_or_default();
+        for key in to_delete {
+            self.delete(&key);
+        }
+    }
+
+    pub(crate) fn enforce_capacity(&mut self, max_entries: usize) {
+        if self.entries.len() <= max_entries {
+            return;
+        }
+        let now = Instant::now();
+        let expired: Vec<String> = self.entries.iter().filter(|(_, s)| s.entry.until <= now).map(|(k, _)| k.clone()).collect();
+        for key in expired {
+            self.delete(&key);
+        }
+        let target = (max_entries / 2).max(1);
+        while self.entries.len() > target {
+            /* the oldest tick; delete() drops the rest of its state */
+            let Some((_, oldest)) = self.order.pop_first() else { break };
+            self.delete(&oldest);
+        }
+    }
+}
+
+/// 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,
+}
+
+/// (enabled, stale_time, max_entries, max_sources) from a config; disabled when absent or stale_time ≤ 0.
+pub(crate) fn tracker_settings(cfg: Option<&InvalidationConfig>) -> (bool, Duration, usize, usize) {
+    let mut out = (false, Duration::from_millis(0), 1000usize, 16usize);
+    if let Some(c) = cfg {
+        if c.stale_time > 0 {
+            out.0 = true;
+            out.1 = Duration::from_millis(c.stale_time as u64);
+            if c.stale_max_entries > 0 {
+                out.2 = c.stale_max_entries;
+            }
+            if c.max_sources_per_target > 0 {
+                out.3 = c.max_sources_per_target;
+            }
+        }
+    }
+    out
+}
+
+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 (enabled, stale_time, max_entries, max_sources) = tracker_settings(cfg);
+        StaleTracker { 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.
+    /// `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;
+        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 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);
+        }
+        self.state.lock().await.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 async fn clear_stale(&self, concrete_selector: &str, concrete_path: &str, method: &str, seq_snapshot: u64) {
+        if !self.enabled {
+            return;
+        }
+        self.state.lock().await.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 async fn is_stale(&self, method: &str, path: &str) -> bool {
+        if !self.enabled {
+            return false;
+        }
+        let selector = format!("{} {}", method, path);
+        self.state.lock().await.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 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) = 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 })
+    }
+}
+
+/// key_is_pattern reports whether a stored `METHOD /path` key holds placeholders.
+pub(crate) fn key_is_pattern(key: &str) -> bool {
+    match key.find(' ') {
+        Some(i) => path_has_placeholders(&key[i + 1..]),
+        None => false,
+    }
+}