Skip to main content

kernel/graph/
resource_properties.rs

1// Copyright 2026 Mark Alan Boykin
2// This Source Code Form is subject to the terms of the Mozilla Public
3// License, v. 2.0. If a copy of the MPL was not distributed with this
4// file, You can obtain one at https://mozilla.org/MPL/2.0/.
5// SPDX-License-Identifier: MPL-2.0
6
7//! Shared literal assertions with exact handles and per-asserter deduplication.
8
9use super::resource_content::{ContentError, RESOURCE_PROPERTIES};
10use super::{Graph, NodeKey};
11use crate::types::NodeProperty;
12use uuid::Uuid;
13
14/// Merge copied assertions by their exact handles, preserving distinct carried IDs.
15pub fn merge_resource_properties(
16    left: &[NodeProperty],
17    right: &[NodeProperty],
18) -> Result<Vec<NodeProperty>, ContentError> {
19    let mut merged = left.to_vec();
20    for property in right {
21        if let Some(existing) = merged
22            .iter()
23            .find(|held| held.statement_id == property.statement_id)
24        {
25            if existing != property {
26                return Err(ContentError::HandleCollision(property.statement_id.clone()));
27            }
28        } else {
29            merged.push(property.clone());
30        }
31    }
32    merged.sort_by(|a, b| a.statement_id.cmp(&b.statement_id));
33    Ok(merged)
34}
35
36impl Graph {
37    pub fn resource_properties(&self, id: Uuid) -> Vec<NodeProperty> {
38        self.resource_content(id, RESOURCE_PROPERTIES)
39            .unwrap_or_default()
40    }
41
42    pub(crate) fn literal_handle_available(&self, resource: Uuid, property: &NodeProperty) -> bool {
43        if self
44            .find_semantic_statement(&property.statement_id)
45            .is_some()
46        {
47            return false;
48        }
49        for node in self.resource_nodes() {
50            for held in self.resource_properties(node.id()) {
51                if held.statement_id == property.statement_id
52                    && (node.id() != resource || !held.content_eq(property))
53                {
54                    return false;
55                }
56            }
57        }
58        for (key, _) in self.nodes() {
59            if self
60                .legacy_node_properties(key)
61                .into_iter()
62                .flatten()
63                .any(|held| held.statement_id == property.statement_id)
64            {
65                return false;
66            }
67        }
68        true
69    }
70
71    pub fn append_resource_properties(
72        &mut self,
73        id: Uuid,
74        incoming: Vec<NodeProperty>,
75    ) -> Result<bool, ContentError> {
76        if self.resource(id).is_none() {
77            return Err(ContentError::MissingResource);
78        }
79        let mut properties = self.resource_properties(id);
80        for mut property in incoming {
81            if property.provenance_iri.is_none() {
82                property.provenance_iri = Some(self.write_author().asserter_iri());
83            }
84            if !self.literal_handle_available(id, &property) {
85                return Err(ContentError::HandleCollision(property.statement_id));
86            }
87            if let Some(existing) = properties
88                .iter_mut()
89                .find(|held| held.content_eq(&property))
90            {
91                existing.asserted_at_ms = property.asserted_at_ms;
92            } else {
93                if properties
94                    .iter()
95                    .any(|held| held.statement_id == property.statement_id)
96                {
97                    return Err(ContentError::HandleCollision(property.statement_id));
98                }
99                properties.push(property);
100            }
101        }
102        self.write_resource_content(id, RESOURCE_PROPERTIES, &properties)
103    }
104
105    pub(crate) fn append_shown_properties(
106        &mut self,
107        key: NodeKey,
108        incoming: Vec<NodeProperty>,
109    ) -> bool {
110        if incoming.is_empty() {
111            return false;
112        }
113        let Some(node) = self.get_node(key) else {
114            return false;
115        };
116        let id = self
117            .shown_resource_id(key)
118            .unwrap_or_else(|| super::ResourceNode::new(node.primary_address().as_url_str()).id());
119        let mut incoming = incoming;
120        for property in &mut incoming {
121            if property.provenance_iri.is_none() {
122                property.provenance_iri = Some(self.write_author().asserter_iri());
123            }
124            if !self.literal_handle_available(id, property) {
125                return false;
126            }
127        }
128        if merge_resource_properties(&[], &incoming).is_err() {
129            return false;
130        }
131        let Some(id) = self.ensure_surface_resource(key) else {
132            return false;
133        };
134        self.append_resource_properties(id, incoming)
135            .unwrap_or(false)
136    }
137
138    pub fn retract_resource_property(
139        &mut self,
140        id: Uuid,
141        statement_id: &str,
142    ) -> Result<bool, ContentError> {
143        let mut properties = self.resource_properties(id);
144        let before = properties.len();
145        properties.retain(|property| property.statement_id != statement_id);
146        if before == properties.len() {
147            return Ok(false);
148        }
149        self.write_resource_content(id, RESOURCE_PROPERTIES, &properties)
150    }
151}