pib-client-cached 0.28.0

API client for pib-service - caching data storage
Documentation
// SPDX-FileCopyrightText: Politik im Blick developers
// SPDX-FileCopyrightText: Wolfgang Silbermayr <wolfgang@silbermayr.at>
//
// SPDX-License-Identifier: AGPL-3.0-or-later OR EUPL-1.2

use cachekit::prelude::{CacheBuilder, DynCache};
use pib_client::PibClient;
use pib_service_core_types::{DataItem, Entity};

use crate::{
    CACHE_POLICY, CACHE_SIZE, ClearableCache, CreateableItem,
    item::{GetableItem, PlaceableItem, UpdatableItem},
};

#[derive(Debug)]
pub(super) struct ItemCache<
    PARENTID: std::fmt::Debug + Copy + Ord + std::hash::Hash,
    ID: std::fmt::Debug + Copy + Ord + std::hash::Hash,
    T: Entity<PARENTID, ID> + std::fmt::Debug + Clone,
> {
    items: DynCache<ID, DataItem<PARENTID, ID, T>>,
}

impl<
    PARENTID: std::fmt::Debug + Copy + Ord + std::hash::Hash,
    ID: std::fmt::Debug + Copy + Ord + std::hash::Hash,
    T: Entity<PARENTID, ID> + std::fmt::Debug + Clone,
> ItemCache<PARENTID, ID, T>
{
    pub fn new() -> Self {
        let items = CacheBuilder::new(CACHE_SIZE).build(CACHE_POLICY);

        Self { items }
    }

    pub fn clear(&mut self) {
        self.items.clear()
    }

    pub fn insert(&mut self, item: DataItem<PARENTID, ID, T>) {
        self.items.insert(item.id, item);
    }

    pub async fn create<C: PibClient, NEWPARENTID, NEW>(
        &mut self,
        client: &C,
        caches_to_clear: Vec<&mut dyn ClearableCache>,
        parent_id: NEWPARENTID,
        new_item: NEW,
    ) -> Result<DataItem<NEWPARENTID, ID, T>, C::ClientError>
    where
        T: CreateableItem<PARENTID, ID, T, NEWPARENTID, NEW> + Entity<NEWPARENTID, ID>,
        PARENTID: From<NEWPARENTID>,
        NEWPARENTID: Clone,
    {
        let created_item = T::create(client, parent_id.clone(), new_item).await?;

        let cache_item = DataItem {
            id: created_item.id,
            parent_id: PARENTID::from(parent_id),
            metadata: created_item.metadata.clone(),
            value: created_item.value.clone(),
        };
        self.insert(cache_item);

        for cache in caches_to_clear {
            cache.clear_cache();
        }

        Ok(created_item)
    }

    pub async fn update<C: PibClient, UPDATE>(
        &mut self,
        client: &C,
        parent_id: PARENTID,
        id: ID,
        update_item: UPDATE,
    ) -> Result<DataItem<PARENTID, ID, T>, C::ClientError>
    where
        T: UpdatableItem<PARENTID, ID, T, UPDATE>,
    {
        let updated_item = T::update(client, parent_id, id, update_item).await?;
        self.insert(updated_item.clone());
        Ok(updated_item)
    }
}

impl<
    PARENTID: std::fmt::Debug + Copy + Ord + std::hash::Hash,
    ID: std::fmt::Debug + Copy + Ord + std::hash::Hash,
    T: GetableItem<PARENTID, ID, T> + Entity<PARENTID, ID> + std::fmt::Debug + Clone,
> ItemCache<PARENTID, ID, T>
{
    pub async fn get<C: PibClient>(
        &mut self,
        client: &C,
        parent_id: PARENTID,
        id: ID,
    ) -> Result<DataItem<PARENTID, ID, T>, C::ClientError> {
        if let Some(item) = self.items.get(&id) {
            return Ok(item.clone());
        }
        let item = T::get(client, parent_id, id).await?;
        self.items.insert(id, item.clone());
        Ok(item)
    }
}

impl<
    PARENTID: std::fmt::Debug + Copy + Ord + std::hash::Hash,
    ID: std::fmt::Debug + Copy + Ord + std::hash::Hash,
    T: PlaceableItem<PARENTID, ID, T> + Entity<PARENTID, ID> + std::fmt::Debug + Clone,
> ItemCache<PARENTID, ID, T>
{
    pub async fn place<C: PibClient, NEWPARENTID, NEW>(
        &mut self,
        client: &C,
        caches_to_clear: Vec<&mut dyn ClearableCache>,
        parent_id: NEWPARENTID,
        id: ID,
        new_item: NEW,
    ) -> Result<DataItem<NEWPARENTID, ID, T>, C::ClientError>
    where
        T: PlaceableItem<PARENTID, ID, T, NEWPARENTID, NEW> + Entity<NEWPARENTID, ID>,
        PARENTID: From<NEWPARENTID>,
        NEWPARENTID: Clone,
    {
        let placed_item = T::place(client, parent_id.clone(), id, new_item).await?;

        let cache_item = DataItem {
            id: placed_item.id,
            parent_id: PARENTID::from(parent_id),
            metadata: placed_item.metadata.clone(),
            value: placed_item.value.clone(),
        };
        self.insert(cache_item);

        for cache in caches_to_clear {
            cache.clear_cache();
        }

        Ok(placed_item)
    }
}

impl<
    PARENTID: std::fmt::Debug + Copy + Ord + std::hash::Hash,
    ID: std::fmt::Debug + Copy + Ord + std::hash::Hash,
    T: Entity<PARENTID, ID> + std::fmt::Debug + Clone,
> ClearableCache for ItemCache<PARENTID, ID, T>
{
    fn clear_cache(&mut self) {
        self.clear();
    }
}