nostralink 0.2.1

Linked data library for nostr
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

//! Bookmarks API

use super::manager::{RdfEventsStore, RdfStoreError};
use nostr::event::EventId;
use oxigraph::model::*;
use std::str::FromStr;
use std::time::{SystemTime, UNIX_EPOCH};
use urn::Urn;

pub trait EventBookmarks {
    fn bookmark(
        &self,
        event_uri: NamedNode,
        title: String,
    ) -> Result<(), RdfStoreError>;
    fn get_bookmarks(
        &self,
    ) -> Result<Vec<(NamedNode, EventId, String)>, RdfStoreError>;
}

fn bookmarks_graph1() -> NamedNode {
    NamedNode::new("urn:nostr-bookmarks:1").unwrap()
}

fn bookmarks_root() -> NamedNode {
    NamedNode::new("urn:nostr-bookmarks:root").unwrap()
}

fn pred_bookmark_event() -> NamedNode {
    NamedNode::new("https://w3id.org/nostr#eventBookmark").unwrap()
}

fn pred_bookmark_title() -> NamedNode {
    NamedNode::new("https://w3id.org/nostr#bookmarkTitle").unwrap()
}

fn pred_bookmark_dateadded() -> NamedNode {
    NamedNode::new("https://w3id.org/nostr#bookmarkDateAdded").unwrap()
}

fn evuri_to_eventid(node: NamedNode) -> Result<EventId, RdfStoreError> {
    let urn = Urn::from_str(node.into_string().as_str())
        .map_err(|_| RdfStoreError::URNError)?;

    Ok(EventId::parse(urn.nss()).map_err(|_| RdfStoreError::URNError)?)
}

const BQUERY: &str = "
SELECT ?root ?event ?title ?date_added
FROM <urn:nostr-bookmarks:1>
WHERE {
?root nostr:eventBookmark ?event .
?event nostr:bookmarkTitle ?title .
?event nostr:bookmarkDateAdded ?date_added .
}
ORDER BY DESC(?date_added)
";

fn get_epoch_ms() -> u64 {
    SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap()
        .as_secs()
}

impl EventBookmarks for RdfEventsStore {
    fn bookmark(
        &self,
        event_uri: NamedNode,
        title: String,
    ) -> Result<(), RdfStoreError> {
        let pred_b = pred_bookmark_event();
        let pred_title = pred_bookmark_title();
        let root = bookmarks_root();
        let bnode = bookmarks_graph1();

        let _ = self
            .store
            .insert(QuadRef::new(&root, &pred_b, &event_uri, &bnode));
        let _ = self.store.insert(QuadRef::new(
            &event_uri,
            &pred_title,
            &Literal::from(title),
            &bnode,
        ));
        let _ = self.store.insert(QuadRef::new(
            &event_uri,
            &pred_bookmark_dateadded(),
            &Literal::from(get_epoch_ms()),
            &bnode,
        ));
        Ok(())
    }

    fn get_bookmarks(
        &self,
    ) -> Result<Vec<(NamedNode, EventId, String)>, RdfStoreError> {
        let subs = [(
            Variable::new("root").unwrap(),
            Term::NamedNode(bookmarks_root()),
        )];

        let results = self
            .run_query(&BQUERY.to_string(), subs, None)
            .map_err(|_| RdfStoreError::QueryError)?;

        let mut v = Vec::new();

        for row in &results.rows {
            let event = row.get("event").unwrap();
            let title = row.get("title").unwrap();

            let event_uri = event
                .value
                .to_named_node()
                .map_err(|_| RdfStoreError::NamedNodeError)?;
            let evid = evuri_to_eventid(event_uri.clone())
                .map_err(|_| RdfStoreError::URNError)
                .unwrap();

            v.push((event_uri.clone(), evid, title.to_string()));
        }

        Ok(v)
    }
}