post-cortex-storage 0.5.0

Storage backends for post-cortex — lock-free RocksDB (default) and optional SurrealDB. Implements the Storage trait against the post-cortex domain types.
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

// Copyright (c) 2025, 2026 Julius ML
// Licensed under the MIT License. See LICENSE at the workspace root.

//! [`CardStorage`] behaviour, run against every backend.

use std::sync::Arc;

use uuid::Uuid;

use crate::traits::{CardStorage, CardWrite, Storage};
use post_cortex_core::core::card::{Card, CardScope};

fn written(write: CardWrite) -> Card {
    match write {
        CardWrite::Written(card) => card,
        CardWrite::Conflict(latest) => panic!("unexpected conflict, latest {latest:?}"),
    }
}

async fn versions_and_conflicts(storage: &impl CardStorage) {
    let scope = CardScope::Workspace(Uuid::new_v4());
    assert_eq!(storage.get_card(scope).await.unwrap(), None);

    let v1 = written(
        storage
            .put_card(scope, "stack: rust".into(), Some("claude".into()), 0)
            .await
            .unwrap(),
    );
    assert_eq!((v1.version, v1.author.as_deref()), (1, Some("claude")));

    // A writer that read no card is too late now.
    match storage
        .put_card(scope, "other".into(), None, 0)
        .await
        .unwrap()
    {
        CardWrite::Conflict(Some(latest)) => assert_eq!(latest, v1),
        other => panic!("expected a conflict, got {other:?}"),
    }

    let v2 = written(
        storage
            .put_card(scope, "stack: rust, surrealdb".into(), None, 1)
            .await
            .unwrap(),
    );
    assert_eq!(v2.version, 2);
    assert_eq!(storage.get_card(scope).await.unwrap(), Some(v2.clone()));

    let history = storage.card_history(scope, 10).await.unwrap();
    assert_eq!(history, vec![v2.clone(), v1], "newest first, all kept");
    assert_eq!(storage.card_history(scope, 1).await.unwrap(), vec![v2]);

    // The user card is its own.
    assert_eq!(storage.get_card(CardScope::User).await.unwrap(), None);
    let user = written(
        storage
            .put_card(CardScope::User, "answers in Bulgarian".into(), None, 0)
            .await
            .unwrap(),
    );
    assert_eq!(user.version, 1);
}

async fn one_of_two_racing_writers_wins<S: CardStorage + 'static>(storage: Arc<S>) {
    let scope = CardScope::Workspace(Uuid::new_v4());
    written(storage.put_card(scope, "v1".into(), None, 0).await.unwrap());
    let a = tokio::spawn({
        let storage = storage.clone();
        async move { storage.put_card(scope, "a".into(), None, 1).await.unwrap() }
    });
    let b = tokio::spawn({
        let storage = storage.clone();
        async move { storage.put_card(scope, "b".into(), None, 1).await.unwrap() }
    });
    let results = [a.await.unwrap(), b.await.unwrap()];
    let wins = results
        .iter()
        .filter(|w| matches!(w, CardWrite::Written(_)))
        .count();
    assert_eq!(wins, 1, "{results:?}");
    assert_eq!(storage.get_card(scope).await.unwrap().unwrap().version, 2);
}

async fn deleting_the_workspace_deletes_its_card(storage: &impl Storage) {
    let workspace = Uuid::new_v4();
    storage
        .save_workspace_metadata(workspace, "ws", "", &[])
        .await
        .unwrap();
    let scope = CardScope::Workspace(workspace);
    written(
        storage
            .put_card(scope, "goals".into(), None, 0)
            .await
            .unwrap(),
    );
    storage.delete_workspace(workspace).await.unwrap();
    assert_eq!(storage.get_card(scope).await.unwrap(), None);
    assert!(storage.card_history(scope, 10).await.unwrap().is_empty());
}

#[tokio::test]
async fn rocksdb_cards() {
    let dir = tempfile::tempdir().unwrap();
    let storage = Arc::new(crate::RealRocksDBStorage::new(dir.path()).await.unwrap());
    versions_and_conflicts(storage.as_ref()).await;
    one_of_two_racing_writers_wins(storage.clone()).await;
    deleting_the_workspace_deletes_its_card(storage.as_ref()).await;
}

#[cfg(feature = "surrealdb-storage")]
#[tokio::test]
async fn surrealdb_cards() {
    let storage = Arc::new(
        crate::SurrealDBStorage::new("mem://", None, None, None, None)
            .await
            .unwrap(),
    );
    versions_and_conflicts(storage.as_ref()).await;
    one_of_two_racing_writers_wins(storage.clone()).await;
    deleting_the_workspace_deletes_its_card(storage.as_ref()).await;
}