kcode-k1-groups 0.3.0

use std::{path::Path, sync::Arc};

use kcode_k1_groups_driver::K1GroupsDriver;
use kcode_k1_groups_projection::Projection;
use kcode_k1_peering::K1Peering;
use kcode_k1_txn_ordering::K1TxnOrdering;

pub use kcode_k1_groups_projection::{
    ALL_MODELS, ALL_USERS, Group, GroupId, GroupMemberships, GroupName, GroupRevision, GroupRole,
    GroupUser, LOCAL_MODELS, ModelId, SentinelGroup, TxId, UserId,
};

pub struct K1Groups {
    driver: K1GroupsDriver,
}

impl K1Groups {
    pub fn open(
        root: &Path,
        ordering: Arc<K1TxnOrdering>,
        peering: Arc<K1Peering>,
    ) -> Result<Self, String> {
        let (projection, checkpoint) = Projection::open(root, &ordering)?;
        let projection = Arc::new(projection);
        let driver = K1GroupsDriver::register(projection, checkpoint, ordering, peering)?;
        Ok(Self { driver })
    }

    pub fn create(&self, owner: UserId, name: GroupName) -> Result<GroupRevision, String> {
        self.driver.create(owner, name)
    }

    pub fn rename(
        &self,
        actor: UserId,
        group: GroupId,
        name: GroupName,
    ) -> Result<GroupRevision, String> {
        self.driver.rename(actor, group, name)
    }

    pub fn set_user_role(
        &self,
        actor: UserId,
        group: GroupId,
        user: UserId,
        role: Option<GroupRole>,
    ) -> Result<GroupRevision, String> {
        self.driver.set_user_role(actor, group, user, role)
    }

    pub fn set_model_membership(
        &self,
        actor: UserId,
        group: GroupId,
        model: ModelId,
        present: bool,
    ) -> Result<GroupRevision, String> {
        self.driver
            .set_model_membership(actor, group, model, present)
    }

    pub fn get(&self, group: GroupId) -> Result<Option<Group>, String> {
        self.driver.get(group)
    }

    pub fn groups_for_user(&self, user: UserId) -> Result<Vec<GroupId>, String> {
        self.driver.groups_for_user(user)
    }

    pub fn groups_for_model(&self, model: ModelId) -> Result<Vec<GroupId>, String> {
        self.driver.groups_for_model(model)
    }

    pub fn memberships(&self, user: UserId, model: ModelId) -> Result<GroupMemberships, String> {
        self.driver.memberships(user, model)
    }
}