From 45df4d0d9b577fecee798d672695fe24ff57fb1b Mon Sep 17 00:00:00 2001
From: mo khan <mo@mokhan.ca>
Date: Tue, 15 Jul 2025 16:37:08 -0600
Subject: feat: migrate from Cedar to SpiceDB authorization system

This is a major architectural change that replaces the Cedar policy-based
authorization system with SpiceDB's relation-based authorization.

Key changes:

- Migrate from Rust to Go implementation
- Replace Cedar policies with SpiceDB schema and relationships
- Switch from envoy `ext_authz` with Cedar to SpiceDB permission checks
- Update build system and dependencies for Go ecosystem
- Maintain Envoy integration for external authorization

This change enables more flexible permission modeling through SpiceDB's
Google Zanzibar inspired relation-based system, supporting complex
hierarchical permissions that were difficult to express in Cedar.

Breaking change: Existing Cedar policies and Rust-based configuration
will no longer work and need to be migrated to SpiceDB schema.
---
 vendor/itertools/src/rciter_impl.rs | 102 ------------------------------------
 1 file changed, 102 deletions(-)
 delete mode 100644 vendor/itertools/src/rciter_impl.rs

(limited to 'vendor/itertools/src/rciter_impl.rs')

diff --git a/vendor/itertools/src/rciter_impl.rs b/vendor/itertools/src/rciter_impl.rs
deleted file mode 100644
index 96a0fd69..00000000
--- a/vendor/itertools/src/rciter_impl.rs
+++ /dev/null
@@ -1,102 +0,0 @@
-use alloc::rc::Rc;
-use std::cell::RefCell;
-use std::iter::{FusedIterator, IntoIterator};
-
-/// A wrapper for `Rc<RefCell<I>>`, that implements the `Iterator` trait.
-#[derive(Debug)]
-#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
-pub struct RcIter<I> {
-    /// The boxed iterator.
-    pub rciter: Rc<RefCell<I>>,
-}
-
-/// Return an iterator inside a `Rc<RefCell<_>>` wrapper.
-///
-/// The returned `RcIter` can be cloned, and each clone will refer back to the
-/// same original iterator.
-///
-/// `RcIter` allows doing interesting things like using `.zip()` on an iterator with
-/// itself, at the cost of runtime borrow checking which may have a performance
-/// penalty.
-///
-/// Iterator element type is `Self::Item`.
-///
-/// ```
-/// use itertools::rciter;
-/// use itertools::zip;
-///
-/// // In this example a range iterator is created and we iterate it using
-/// // three separate handles (two of them given to zip).
-/// // We also use the IntoIterator implementation for `&RcIter`.
-///
-/// let mut iter = rciter(0..9);
-/// let mut z = zip(&iter, &iter);
-///
-/// assert_eq!(z.next(), Some((0, 1)));
-/// assert_eq!(z.next(), Some((2, 3)));
-/// assert_eq!(z.next(), Some((4, 5)));
-/// assert_eq!(iter.next(), Some(6));
-/// assert_eq!(z.next(), Some((7, 8)));
-/// assert_eq!(z.next(), None);
-/// ```
-///
-/// **Panics** in iterator methods if a borrow error is encountered in the
-/// iterator methods. It can only happen if the `RcIter` is reentered in
-/// `.next()`, i.e. if it somehow participates in an “iterator knot”
-/// where it is an adaptor of itself.
-pub fn rciter<I>(iterable: I) -> RcIter<I::IntoIter>
-where
-    I: IntoIterator,
-{
-    RcIter {
-        rciter: Rc::new(RefCell::new(iterable.into_iter())),
-    }
-}
-
-impl<I> Clone for RcIter<I> {
-    clone_fields!(rciter);
-}
-
-impl<A, I> Iterator for RcIter<I>
-where
-    I: Iterator<Item = A>,
-{
-    type Item = A;
-    #[inline]
-    fn next(&mut self) -> Option<Self::Item> {
-        self.rciter.borrow_mut().next()
-    }
-
-    #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        // To work sanely with other API that assume they own an iterator,
-        // so it can't change in other places, we can't guarantee as much
-        // in our size_hint. Other clones may drain values under our feet.
-        (0, self.rciter.borrow().size_hint().1)
-    }
-}
-
-impl<I> DoubleEndedIterator for RcIter<I>
-where
-    I: DoubleEndedIterator,
-{
-    #[inline]
-    fn next_back(&mut self) -> Option<Self::Item> {
-        self.rciter.borrow_mut().next_back()
-    }
-}
-
-/// Return an iterator from `&RcIter<I>` (by simply cloning it).
-impl<I> IntoIterator for &RcIter<I>
-where
-    I: Iterator,
-{
-    type Item = I::Item;
-    type IntoIter = RcIter<I>;
-
-    fn into_iter(self) -> RcIter<I> {
-        self.clone()
-    }
-}
-
-impl<A, I> FusedIterator for RcIter<I> where I: FusedIterator<Item = A> {}
-- 
cgit v1.2.3