datafold 0.1.55

A personal database for data sovereignty with AI-powered ingestion
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

use super::core::DbOperations;
use crate::schema::SchemaError;
use uuid::Uuid;

impl DbOperations {
    /// Retrieves or generates and persists the node identifier
    pub async fn get_node_id(&self) -> Result<String, SchemaError> {
        use crate::storage::traits::TypedStore;

        // Try to get existing node_id (handle deserialization errors gracefully)
        match self.metadata_store().get_item::<String>("node_id").await {
            Ok(Some(id)) if !id.is_empty() => {
                return Ok(id);
            }
            Ok(Some(_)) | Ok(None) => {
                // Empty or missing - create new
            }
            Err(e) => {
                // Deserialization error (e.g., old format) - create new node_id
                log::warn!(
                    "Failed to deserialize node_id (possibly old format): {}, creating new",
                    e
                );
            }
        }

        // Generate new node_id
        let new_id = Uuid::new_v4().to_string();
        self.set_node_id(&new_id).await?;
        Ok(new_id)
    }

    /// Sets the node identifier
    pub async fn set_node_id(&self, node_id: &str) -> Result<(), SchemaError> {
        use crate::storage::traits::TypedStore;

        self.metadata_store()
            .put_item("node_id", &node_id.to_string())
            .await
            .map_err(|e| SchemaError::InvalidData(format!("Failed to set node_id: {}", e)))?;

        // Flush to ensure persistence
        self.metadata_store()
            .inner()
            .flush()
            .await
            .map_err(|e| SchemaError::InvalidData(format!("Failed to flush metadata: {}", e)))?;

        Ok(())
    }

    /// Retrieves the list of permitted schemas for the given node
    pub async fn get_schema_permissions(&self, node_id: &str) -> Result<Vec<String>, SchemaError> {
        use crate::storage::traits::TypedStore;

        self.permissions_store()
            .get_item::<Vec<String>>(node_id)
            .await
            .map_err(|e| SchemaError::InvalidData(format!("Failed to get permissions: {}", e)))
            .map(|opt| opt.unwrap_or_default())
    }

    /// Sets the permitted schemas for the given node
    pub async fn set_schema_permissions(
        &self,
        node_id: &str,
        schemas: &[String],
    ) -> Result<(), SchemaError> {
        use crate::storage::traits::TypedStore;

        let schemas_vec: Vec<String> = schemas.to_vec();
        self.permissions_store()
            .put_item(node_id, &schemas_vec)
            .await
            .map_err(|e| SchemaError::InvalidData(format!("Failed to set permissions: {}", e)))
    }

    /// Lists all nodes with permissions
    pub async fn list_nodes_with_permissions(&self) -> Result<Vec<String>, SchemaError> {
        use crate::storage::traits::TypedStore;

        self.permissions_store()
            .list_keys_with_prefix("")
            .await
            .map_err(|e| SchemaError::InvalidData(format!("Failed to list nodes: {}", e)))
    }

    /// Deletes permissions for a node
    pub async fn delete_schema_permissions(&self, node_id: &str) -> Result<bool, SchemaError> {
        use crate::storage::traits::TypedStore;

        self.permissions_store()
            .delete_item(node_id)
            .await
            .map_err(|e| SchemaError::InvalidData(format!("Failed to delete permissions: {}", e)))
    }

    /// Checks if a node has permissions set
    pub async fn node_has_permissions(&self, node_id: &str) -> Result<bool, SchemaError> {
        use crate::storage::traits::TypedStore;

        self.permissions_store()
            .exists_item(node_id)
            .await
            .map_err(|e| SchemaError::InvalidData(format!("Failed to check permissions: {}", e)))
    }
}