picante 2.0.0

An async incremental query runtime
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312

use picante::PicanteResult;
use std::sync::atomic::{AtomicUsize, Ordering};

static LEN_CALLS: AtomicUsize = AtomicUsize::new(0);
static SUM_CALLS: AtomicUsize = AtomicUsize::new(0);
static UNIT_CALLS: AtomicUsize = AtomicUsize::new(0);

#[picante::input]
pub struct Text {
    #[key]
    pub key: String,
    pub value: String,
}

#[picante::tracked]
pub async fn len<DB: HasTextIngredient>(db: &DB, text: Text) -> PicanteResult<u64> {
    LEN_CALLS.fetch_add(1, Ordering::Relaxed);
    Ok(text.value(db)?.len() as u64)
}

#[picante::tracked]
pub async fn sum<DB>(db: &DB, x: u32, y: u32) -> u64 {
    let _ = db;
    SUM_CALLS.fetch_add(1, Ordering::Relaxed);
    (x as u64) + (y as u64)
}

#[picante::tracked]
pub async fn unit_key<DB>(db: &DB) -> u64 {
    let _ = db;
    UNIT_CALLS.fetch_add(1, Ordering::Relaxed);
    42
}

#[picante::interned]
pub struct Word {
    pub text: String,
}

#[picante::db(inputs(Text), interned(Word), tracked(len, sum, unit_key))]
struct Db {
    pub config: u32,
    pub enabled: bool,
}

#[tokio_test_lite::test]
async fn macros_basic_flow() -> PicanteResult<()> {
    LEN_CALLS.store(0, Ordering::Relaxed);
    let db = Db::new(123, true);
    assert_eq!(db.config, 123);
    assert!(db.enabled);
    let text = Text::new(&db, "a".into(), "hello".into())?;

    assert_eq!(len(&db, text).await?, 5);
    assert_eq!(len(&db, text).await?, 5);
    assert_eq!(LEN_CALLS.load(Ordering::Relaxed), 1);

    Ok(())
}

#[tokio_test_lite::test]
async fn macros_tuple_keys_and_unit_key() -> PicanteResult<()> {
    SUM_CALLS.store(0, Ordering::Relaxed);
    UNIT_CALLS.store(0, Ordering::Relaxed);

    let db = Db::new(0, false);

    assert_eq!(sum(&db, 1, 2).await?, 3);
    assert_eq!(sum(&db, 1, 2).await?, 3);
    assert_eq!(SUM_CALLS.load(Ordering::Relaxed), 1);

    assert_eq!(sum(&db, 2, 3).await?, 5);
    assert_eq!(sum(&db, 2, 3).await?, 5);
    assert_eq!(SUM_CALLS.load(Ordering::Relaxed), 2);

    assert_eq!(unit_key(&db).await?, 42);
    assert_eq!(unit_key(&db).await?, 42);
    assert_eq!(UNIT_CALLS.load(Ordering::Relaxed), 1);

    Ok(())
}

#[tokio_test_lite::test]
async fn macros_interned_works() -> PicanteResult<()> {
    let db = Db::new(0, false);

    let w1 = Word::new(&db, "hello".to_string())?;
    let w2 = Word::new(&db, "hello".to_string())?;
    assert_eq!(w1, w2);
    assert_eq!(w1.text(&db)?, "hello".to_string());

    Ok(())
}

mod db_paths {
    use super::*;
    use std::sync::atomic::{AtomicUsize, Ordering};

    static CALLS: AtomicUsize = AtomicUsize::new(0);

    #[picante::input]
    pub struct Text2 {
        #[key]
        pub key: String,
        pub value: String,
    }

    #[picante::tracked]
    pub async fn len2<DB: HasText2Ingredient>(db: &DB, text: Text2) -> PicanteResult<u64> {
        CALLS.fetch_add(1, Ordering::Relaxed);
        Ok(text.value(db)?.len() as u64)
    }

    #[picante::interned]
    pub struct Word2 {
        pub text: String,
    }

    #[picante::db(inputs(self::Text2), interned(self::Word2), tracked(self::len2))]
    pub struct Db2 {}

    #[tokio_test_lite::test]
    async fn db_macro_accepts_paths() -> PicanteResult<()> {
        CALLS.store(0, Ordering::Relaxed);
        let db = Db2::new();
        let text = Text2::new(&db, "a".into(), "hello".into())?;

        assert_eq!(len2(&db, text).await?, 5);
        assert_eq!(len2(&db, text).await?, 5);
        assert_eq!(CALLS.load(Ordering::Relaxed), 1);

        let w1 = Word2::new(&db, "hello".to_string())?;
        let w2 = Word2::new(&db, "hello".to_string())?;
        assert_eq!(w1, w2);

        Ok(())
    }
}

/// Tests for the combined db trait feature (#7)
mod db_trait {
    use picante::PicanteResult;
    use std::sync::atomic::{AtomicUsize, Ordering};

    static QUERY_CALLS: AtomicUsize = AtomicUsize::new(0);

    #[picante::input]
    pub struct Item {
        #[key]
        pub id: u32,
        pub name: String,
    }

    #[picante::interned]
    pub struct Tag {
        pub label: String,
    }

    // Tracked functions use the combined trait to access inputs/interned
    #[picante::tracked]
    pub async fn process_item<DB: DatabaseTrait>(db: &DB, item: Item) -> PicanteResult<String> {
        QUERY_CALLS.fetch_add(1, Ordering::Relaxed);
        let name = item.name(db)?;
        // We can access Tag via the combined trait
        let _tag = Tag::new(db, format!("tag-{}", name))?;
        Ok(format!("processed: {}", name))
    }

    // Default trait name: {DbName}Trait
    #[picante::db(inputs(Item), interned(Tag), tracked(process_item))]
    pub struct Database {}

    // Generic function that operates on data sources (inputs + interned)
    // doesn't need query access - just reads/creates data
    fn create_tagged_item<DB: DatabaseTrait>(
        db: &DB,
        id: u32,
        name: &str,
    ) -> PicanteResult<(Item, Tag)> {
        let item = Item::new(db, id, name.to_string())?;
        let tag = Tag::new(db, format!("tag-{}", name))?;
        Ok((item, tag))
    }

    #[tokio_test_lite::test]
    async fn combined_trait_works() -> PicanteResult<()> {
        QUERY_CALLS.store(0, Ordering::Relaxed);

        let db = Database::new();

        // Use the generic function that uses DatabaseTrait bound
        let (item, tag) = create_tagged_item(&db, 1, "foo")?;
        assert_eq!(item.name(&db)?, "foo");
        assert_eq!(tag.label(&db)?, "tag-foo");

        // Call the tracked query (uses HasProcessItemQuery bound internally)
        let result = process_item(&db, item).await?;
        assert_eq!(result, "processed: foo");
        assert_eq!(QUERY_CALLS.load(Ordering::Relaxed), 1);

        // Cached on second call
        let result = process_item(&db, item).await?;
        assert_eq!(result, "processed: foo");
        assert_eq!(QUERY_CALLS.load(Ordering::Relaxed), 1);

        Ok(())
    }

    // Test custom trait name via db_trait()
    mod custom_name {
        use picante::PicanteResult;

        #[picante::input]
        pub struct Entry {
            #[key]
            pub key: String,
            pub value: String,
        }

        #[picante::tracked]
        pub async fn get_value<DB: Db>(db: &DB, entry: Entry) -> PicanteResult<String> {
            Ok(entry.value(db)?.to_string())
        }

        // Custom trait name: Db
        #[picante::db(inputs(Entry), tracked(get_value), db_trait(Db))]
        pub struct AppDatabase {}

        // Function using the custom trait name for data access
        fn create_entry<DB: Db>(db: &DB, key: &str, value: &str) -> PicanteResult<Entry> {
            Entry::new(db, key.to_string(), value.to_string())
        }

        #[tokio_test_lite::test]
        async fn custom_trait_name_works() -> PicanteResult<()> {
            let db = AppDatabase::new();

            // Use generic function with custom Db trait
            let entry = create_entry(&db, "test-key", "test-value")?;
            assert_eq!(entry.key(&db)?.as_ref(), "test-key");

            // Call tracked query
            let value = get_value(&db, entry).await?;
            assert_eq!(value, "test-value");

            Ok(())
        }
    }
}

/// Tests for singleton inputs (no #[key] field)
mod singleton {
    use picante::PicanteResult;

    /// A singleton config - no #[key] field means only one instance
    #[picante::input]
    pub struct Config {
        pub debug: bool,
        pub timeout: u64,
    }

    // Test singleton with tracked query
    #[picante::tracked]
    pub async fn get_timeout<DB: DatabaseTrait>(db: &DB) -> PicanteResult<Option<u64>> {
        Config::timeout(db)
    }

    #[picante::db(inputs(Config), tracked(get_timeout))]
    pub struct Database {}

    #[tokio_test_lite::test]
    async fn singleton_set_and_get() -> PicanteResult<()> {
        let db = Database::new();

        // Initially not set
        assert!(Config::get(&db)?.is_none());
        assert!(Config::debug(&db)?.is_none());

        // Set the singleton
        Config::set(&db, true, 30)?;

        // Now it's set
        let config = Config::get(&db)?.expect("config should be set");
        assert!(config.debug);
        assert_eq!(config.timeout, 30);

        // Field accessors work
        assert_eq!(Config::debug(&db)?, Some(true));
        assert_eq!(Config::timeout(&db)?, Some(30));

        // Update the singleton
        Config::set(&db, false, 60)?;
        assert_eq!(Config::debug(&db)?, Some(false));
        assert_eq!(Config::timeout(&db)?, Some(60));

        Ok(())
    }

    #[tokio_test_lite::test]
    async fn singleton_with_tracked() -> PicanteResult<()> {
        let db = Database::new();

        // Query returns None when not set
        assert_eq!(get_timeout(&db).await?, None);

        // Set and query
        Config::set(&db, true, 42)?;
        assert_eq!(get_timeout(&db).await?, Some(42));

        Ok(())
    }
}