nostralink 0.1.9

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

use super::manager::{RdfEventsStore, RdfStoreError};
use crate::niri::{FromNamedNode, ToNamedNode};
use nostr::PublicKey;
use oxigraph::model::*;
use std::collections::HashSet;

pub trait MuteManager {
    fn mute(
        &self,
        muter_pubk: &PublicKey,
        muted_pubk: &PublicKey,
    ) -> Result<(), RdfStoreError>;

    fn muting(
        &self,
        muter_pubk: &PublicKey,
        muted_pubk: &PublicKey,
    ) -> Result<bool, RdfStoreError>;

    fn unmute(
        &self,
        muter_pubk: &PublicKey,
        muted_pubk: &PublicKey,
    ) -> Result<(), RdfStoreError>;

    fn all_muted_pubkeys(&self) -> Result<HashSet<PublicKey>, RdfStoreError>;
}

fn pred_mutes() -> NamedNode {
    NamedNode::new_unchecked("https://w3id.org/nostr#mutes")
}

impl MuteManager for RdfEventsStore {
    fn mute(
        &self,
        muter_pubk: &PublicKey,
        muted_pubk: &PublicKey,
    ) -> Result<(), RdfStoreError> {
        let muter_nn = muter_pubk.named_node()?;
        let muted_nn = muted_pubk.named_node()?;

        let _ = self.store.insert(QuadRef::new(
            &muter_nn,
            &pred_mutes(),
            &muted_nn,
            &GraphName::DefaultGraph,
        ));
        Ok(())
    }

    fn muting(
        &self,
        muter_pubk: &PublicKey,
        muted_pubk: &PublicKey,
    ) -> Result<bool, RdfStoreError> {
        let muter_nn = muter_pubk.named_node()?;
        let muted_nn = muted_pubk.named_node()?;

        let results = self
            .store
            .quads_for_pattern(
                Some((&muter_nn).into()),
                Some((&pred_mutes()).into()),
                Some((&muted_nn).into()),
                None,
            )
            .collect::<Result<Vec<_>, _>>()
            .map_err(|_| RdfStoreError::QueryError)?;

        Ok(results.len() > 0)
    }

    fn unmute(
        &self,
        muter_pubk: &PublicKey,
        muted_pubk: &PublicKey,
    ) -> Result<(), RdfStoreError> {
        let muter_nn = muter_pubk.named_node()?;
        let muted_nn = muted_pubk.named_node()?;

        let _ = self.store.remove(QuadRef::new(
            &muter_nn,
            &pred_mutes(),
            &muted_nn,
            &GraphName::DefaultGraph,
        ));
        Ok(())
    }

    fn all_muted_pubkeys(&self) -> Result<HashSet<PublicKey>, RdfStoreError> {
        let results = self
            .store
            .quads_for_pattern(None, Some((&pred_mutes()).into()), None, None)
            .collect::<Result<HashSet<_>, _>>()
            .map_err(|_| RdfStoreError::QueryError)?;

        Ok(results
            .iter()
            .filter_map(|quad| match &quad.object {
                Term::NamedNode(node) => match node.from_named_node() {
                    Ok(pubk) => Some(pubk),
                    Err(_) => None,
                },
                _ => None,
            })
            .collect())
    }
}