sassi 0.1.0-beta.2

Typed in-memory pool with composable predicate algebra and cross-runtime trait queries.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

#![cfg(not(any(
    all(feature = "runtime-tokio", not(target_arch = "wasm32")),
    all(feature = "runtime-wasm", target_arch = "wasm32"),
)))]

use sassi::{
    Cacheable, DeltaPunnuFetcher, DeltaQuery, DeltaResult, DeltaSyncCacheable, FetchError, Field,
    Punnu, PunnuFetcher, RefreshMode,
};
use std::collections::HashSet;
use std::time::Duration;

#[derive(Debug, Clone)]
struct Item {
    id: u64,
    watermark: u64,
}

#[derive(Default)]
struct ItemFields {
    #[allow(dead_code)]
    id: Field<Item, u64>,
    #[allow(dead_code)]
    watermark: Field<Item, u64>,
}

impl Cacheable for Item {
    type Id = u64;
    type Fields = ItemFields;

    fn id(&self) -> Self::Id {
        self.id
    }

    fn fields() -> Self::Fields {
        ItemFields {
            id: Field::new("id", |item| &item.id),
            watermark: Field::new("watermark", |item| &item.watermark),
        }
    }
}

impl DeltaSyncCacheable for Item {
    type Watermark = u64;

    fn watermark(&self) -> Self::Watermark {
        self.watermark
    }
}

#[derive(Clone)]
struct PeriodicFetcher;

#[derive(Clone)]
struct DeltaFetcher;

#[async_trait::async_trait]
impl PunnuFetcher<Item> for PeriodicFetcher {
    async fn fetch(&self) -> Result<Vec<Item>, FetchError> {
        Ok(Vec::new())
    }
}

#[async_trait::async_trait]
impl DeltaPunnuFetcher<Item> for DeltaFetcher {
    async fn fetch_delta(
        &self,
        _query: DeltaQuery<Item>,
    ) -> Result<DeltaResult<Item, u64>, FetchError> {
        Ok(DeltaResult::new(Vec::new(), HashSet::new()))
    }
}

#[test]
#[should_panic(
    expected = "Punnu::start_periodic_refresh requires `runtime-tokio` on native targets or `runtime-wasm` on wasm32"
)]
fn start_periodic_refresh_rejects_missing_target_runtime_feature() {
    let punnu = Punnu::<Item>::builder().build();
    let _ = punnu.start_periodic_refresh(
        Duration::from_secs(1),
        PeriodicFetcher,
        RefreshMode::UpsertOnly,
    );
}

#[test]
#[should_panic(
    expected = "Punnu::start_delta_refresh requires `runtime-tokio` on native targets or `runtime-wasm` on wasm32"
)]
fn start_delta_refresh_rejects_missing_target_runtime_feature() {
    let punnu = Punnu::<Item>::builder().build();
    let _ = punnu.start_delta_refresh(Duration::from_secs(1), DeltaFetcher);
}