use serde::{Deserialize, Serialize};
use crate::manifest::{NoFetcher, delete_manifest};
use crate::schema::{
ManifestId, ModerationState, PrivacyClass, ProvenanceOrigin, ProvenanceRecord, SchemaRef,
Timestamp, TrustEnvelope, TrustLevel,
};
use crate::typed::{TypedPayload, list_typed, load_typed, save_typed};
use crate::{Result, Store};
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct DeletedNode {
pub node_id: String,
pub url: String,
pub title: Option<String>,
pub tags: Vec<String>,
pub graph_id: Option<String>,
pub deleted_at_ms: u64,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub nested: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub facets: Option<serde_json::Value>,
}
impl TypedPayload for DeletedNode {
fn schema_ref() -> SchemaRef {
SchemaRef::from_id(ManifestId::of_blob(b"schema:mere/deleted-node/v1"))
}
}
pub async fn record_deleted(store: &mut dyn Store, deleted: &DeletedNode) -> Result<ManifestId> {
let at = Timestamp(deleted.deleted_at_ms);
save_typed(
store,
deleted,
Vec::new(),
PrivacyClass::LocalOnly,
ProvenanceRecord {
origin: ProvenanceOrigin::Generated,
upstream: Vec::new(),
tooling: Some("mere/deleted-node/v1".to_string()),
generated_at: at,
},
TrustEnvelope {
level: TrustLevel::SelfAsserted,
signatures: Vec::new(),
moderation_state: ModerationState::Unreviewed,
},
at,
)
.await
}
pub async fn list_deleted(store: &mut dyn Store) -> Result<Vec<DeletedNode>> {
let manifests = list_typed::<DeletedNode>(store).await?;
let mut fetcher = NoFetcher;
let mut out = Vec::with_capacity(manifests.len());
for manifest in manifests {
if let Some(node) = load_typed::<DeletedNode>(store, &mut fetcher, manifest.id).await? {
out.push(node);
}
}
out.sort_by(|a, b| b.deleted_at_ms.cmp(&a.deleted_at_ms));
Ok(out)
}
pub async fn purge_deleted(store: &mut dyn Store, node_id: &str) -> Result<usize> {
let manifests = list_typed::<DeletedNode>(store).await?;
let mut fetcher = NoFetcher;
let mut victims = Vec::new();
for manifest in manifests {
if let Some(node) = load_typed::<DeletedNode>(store, &mut fetcher, manifest.id).await? {
if node.node_id == node_id {
victims.push(manifest.id);
}
}
}
let mut purged = 0;
for id in victims {
if delete_manifest(store, id).await? {
purged += 1;
}
}
Ok(purged)
}
pub async fn clear_deleted(store: &mut dyn Store) -> Result<usize> {
let manifests = list_typed::<DeletedNode>(store).await?;
let mut cleared = 0;
for manifest in manifests {
if delete_manifest(store, manifest.id).await? {
cleared += 1;
}
}
Ok(cleared)
}
#[cfg(test)]
mod tests {
use super::*;
use async_trait::async_trait;
use std::collections::HashMap;
use muniment::MemoryBackend as InMemoryStore;
fn tombstone(url: &str, at: u64) -> DeletedNode {
DeletedNode {
node_id: format!("id-{url}"),
url: url.to_string(),
title: Some(format!("title for {url}")),
tags: vec!["reading".to_string()],
graph_id: Some("graph-1".to_string()),
deleted_at_ms: at,
nested: None,
facets: None,
}
}
#[test]
fn recorded_tombstones_list_newest_first() {
pollster::block_on(async {
let mut store = InMemoryStore::default();
record_deleted(&mut store, &tombstone("https://a.test", 1_000))
.await
.unwrap();
record_deleted(&mut store, &tombstone("https://b.test", 3_000))
.await
.unwrap();
record_deleted(&mut store, &tombstone("https://c.test", 2_000))
.await
.unwrap();
let listed = list_deleted(&mut store).await.unwrap();
assert_eq!(listed.len(), 3);
assert_eq!(listed[0].url, "https://b.test");
assert_eq!(listed[1].url, "https://c.test");
assert_eq!(listed[2].url, "https://a.test");
assert_eq!(listed[0].tags, vec!["reading".to_string()]);
assert_eq!(listed[0].title.as_deref(), Some("title for https://b.test"));
});
}
#[test]
fn list_deleted_is_empty_on_a_fresh_store() {
pollster::block_on(async {
let mut store = InMemoryStore::default();
assert!(list_deleted(&mut store).await.unwrap().is_empty());
});
}
#[test]
fn purge_forgets_one_node_and_clear_empties_the_bin() {
pollster::block_on(async {
let mut store = InMemoryStore::default();
record_deleted(&mut store, &tombstone("https://a.test", 1_000))
.await
.unwrap();
record_deleted(&mut store, &tombstone("https://b.test", 2_000))
.await
.unwrap();
let purged = purge_deleted(&mut store, "id-https://a.test")
.await
.unwrap();
assert_eq!(purged, 1, "one tombstone purged");
let listed = list_deleted(&mut store).await.unwrap();
assert_eq!(listed.len(), 1);
assert_eq!(listed[0].url, "https://b.test", "the other survives");
assert_eq!(
purge_deleted(&mut store, "id-https://a.test")
.await
.unwrap(),
0
);
assert_eq!(clear_deleted(&mut store).await.unwrap(), 1);
assert!(list_deleted(&mut store).await.unwrap().is_empty());
assert_eq!(clear_deleted(&mut store).await.unwrap(), 0);
});
}
}