@lovrozagar/honey 0.7.2 → 1.0.0-rc.1

package/dist/client-rust/errors.rs

@@ -1,220 +0,0 @@
-/* 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

@@ -1,412 +0,0 @@
-/* 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,
-    }
-}