jcoffey-dev
a8fb10458b
Personal-data catalog spec, §6 (Phase 3c). inbuxa:DataInventory/get evaluates the catalog against the server's live settings and says what this server holds: for each source and each object that can hold personal data, its categories and whose data it is, whether it is collected here at all, what bounds its retention (the live value of the setting that does, or unbounded), whether it leaves the host and to which endpoints, and a summary. Every host that receives something is listed once as a candidate processor with what it receives. Inside a tenant it answers with the tenant's slice and none of the server's processors. Read-only, with sysComplianceGet. inbuxa:InventorySnapshot/get is the history: a dated copy of the evaluated inventory, recorded when it changes -- after a registry write to an object the inventory reads, after inbuxa's log, audit or AI settings change, and on the daily clean-up -- and kept as long as the audit log's records. ids: null lists every snapshot, newest first; the full inventory only when asked for. The catalog is embedded and parsed at start (new dependency: toml, MIT/Apache); the evaluation is a pure function of it and the live facts, so each configuration is tested without a server. Loopback endpoints stay on the host; any other configured endpoint leaves it. Tested: unit tests for the evaluation (a new install's defaults, an external blob store, a hosted AI endpoint, telemetry off, a tenant's slice, hosts from URLs, loopback), snapshots, and the fact gathering's store and duration rules; the compliance system test, extended (the officer reads the inventory, a plain user is refused, a tenant's officer sees its slice and no processors, a webhook to another host becomes a processor and a snapshot names x:WebHook, a retention change reads through); the system, audit, legal hold and account lock suites; fork checks. The system suite failed once of three runs with an email import's blob not found, in antispam.rs; the same happened once in purge.rs on the previous branch. Nothing here touches uploads; noted for a separate look.
227 lines
6.0 KiB
Rust
227 lines
6.0 KiB
Rust
/*
|
|
* SPDX-FileCopyrightText: 2020 Stalwart Labs LLC <[email protected]>
|
|
*
|
|
* SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-SEL
|
|
*
|
|
* Modified by Coffey Labs in 2026 for INBUXA.
|
|
*/
|
|
|
|
use crate::request::deserialize::DeserializeArguments;
|
|
use jmap_tools::{Element, Null, Property};
|
|
use serde::Serialize;
|
|
use std::{fmt::Debug, str::FromStr};
|
|
use types::{acl::Acl, blob::BlobId, id::Id};
|
|
|
|
pub mod addressbook;
|
|
pub mod blob;
|
|
pub mod calendar;
|
|
pub mod calendar_event;
|
|
pub mod calendar_event_notification;
|
|
pub mod contact;
|
|
pub mod email;
|
|
pub mod email_submission;
|
|
pub mod fastmail_masked_email; // inbuxa: masked email
|
|
pub mod inbuxa_account_lock; // inbuxa: account lock with delegation
|
|
pub mod inbuxa_ai_limits; // inbuxa: AI spam classification
|
|
pub mod inbuxa_log_settings; // inbuxa: personal-data catalog, D1
|
|
pub mod inbuxa_data_inventory; // inbuxa: personal-data catalog
|
|
pub mod inbuxa_inventory_snapshot; // inbuxa: personal-data catalog
|
|
pub mod inbuxa_audit; // inbuxa: the audit log
|
|
pub mod inbuxa_legal_hold; // inbuxa: legal hold
|
|
pub mod inbuxa_hold_export; // inbuxa: legal hold exports
|
|
pub mod inbuxa_explanation; // inbuxa: "Explain this" with the local model
|
|
pub mod inbuxa_protocol_policy; // inbuxa: legacy protocols off
|
|
pub mod inbuxa_tenant_protocol_policy; // inbuxa: legacy protocols off, per tenant
|
|
pub mod inbuxa_deleted_account; // inbuxa: undelete
|
|
pub mod file_node;
|
|
pub mod identity;
|
|
pub mod mailbox;
|
|
pub mod participant_identity;
|
|
pub mod principal;
|
|
pub mod push_subscription;
|
|
pub mod quota;
|
|
pub mod registry;
|
|
pub mod search_snippet;
|
|
pub mod share_notification;
|
|
pub mod sieve;
|
|
pub mod thread;
|
|
pub mod vacation_response;
|
|
|
|
pub trait JmapObject: std::fmt::Debug {
|
|
type Property: Property + JmapObjectId + FromStr + Debug + Sync + Send;
|
|
type Element: Element<Property = Self::Property> + JmapObjectId + Debug + Sync + Send;
|
|
type Id: FromStr + TryFrom<AnyId> + Into<Self::Element> + Serialize + Debug + Sync + Send;
|
|
|
|
type Filter: Default + for<'de> DeserializeArguments<'de> + Debug + Sync + Send;
|
|
type Comparator: Default + for<'de> DeserializeArguments<'de> + Debug + Sync + Send;
|
|
|
|
type GetArguments: Default + for<'de> DeserializeArguments<'de> + Debug + Sync + Send;
|
|
type SetArguments<'de>: Default + DeserializeArguments<'de> + Debug + Sync + Send;
|
|
type QueryArguments: Default + for<'de> DeserializeArguments<'de> + Debug + Sync + Send;
|
|
type CopyArguments: Default + for<'de> DeserializeArguments<'de> + Debug + Sync + Send;
|
|
type ParseArguments: Default + for<'de> DeserializeArguments<'de> + Debug + Sync + Send;
|
|
|
|
const ID_PROPERTY: Self::Property;
|
|
}
|
|
|
|
pub trait JmapSharedObject: JmapObject {
|
|
type Right: JmapRight + Into<Self::Property> + Debug + Clone + Copy + Sync + Send;
|
|
|
|
const SHARE_WITH_PROPERTY: Self::Property;
|
|
}
|
|
|
|
pub trait JmapRight: Clone + Copy + Sized + 'static {
|
|
fn all_rights() -> &'static [Self];
|
|
fn to_acl(&self) -> &'static [Acl];
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
|
|
#[serde(untagged)]
|
|
pub enum AnyId {
|
|
Id(Id),
|
|
BlobId(BlobId),
|
|
}
|
|
|
|
pub trait JmapObjectId {
|
|
fn as_id(&self) -> Option<Id>;
|
|
fn as_any_id(&self) -> Option<AnyId>;
|
|
fn as_id_ref(&self) -> Option<&str>;
|
|
fn try_set_id(&mut self, new_id: AnyId) -> bool;
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
enum MaybeReference<T: FromStr> {
|
|
Value(T),
|
|
Reference(String),
|
|
ParseError,
|
|
}
|
|
|
|
fn parse_ref<T: FromStr>(value: &str) -> MaybeReference<T> {
|
|
if let Some(reference) = value.strip_prefix('#') {
|
|
MaybeReference::Reference(reference.to_string())
|
|
} else {
|
|
T::from_str(value)
|
|
.map(MaybeReference::Value)
|
|
.unwrap_or(MaybeReference::ParseError)
|
|
}
|
|
}
|
|
|
|
impl From<Id> for AnyId {
|
|
fn from(value: Id) -> Self {
|
|
AnyId::Id(value)
|
|
}
|
|
}
|
|
|
|
impl From<BlobId> for AnyId {
|
|
fn from(value: BlobId) -> Self {
|
|
AnyId::BlobId(value)
|
|
}
|
|
}
|
|
|
|
impl TryFrom<AnyId> for Id {
|
|
type Error = ();
|
|
|
|
fn try_from(value: AnyId) -> Result<Self, Self::Error> {
|
|
if let AnyId::Id(id) = value {
|
|
Ok(id)
|
|
} else {
|
|
Err(())
|
|
}
|
|
}
|
|
}
|
|
|
|
impl TryFrom<AnyId> for BlobId {
|
|
type Error = ();
|
|
|
|
fn try_from(value: AnyId) -> Result<Self, Self::Error> {
|
|
if let AnyId::BlobId(id) = value {
|
|
Ok(id)
|
|
} else {
|
|
Err(())
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'de> serde::Deserialize<'de> for AnyId {
|
|
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
|
|
where
|
|
D: serde::Deserializer<'de>,
|
|
{
|
|
let value = <&str>::deserialize(deserializer)?;
|
|
if let Some(blob_id) = BlobId::from_base32(value) {
|
|
Ok(AnyId::BlobId(blob_id))
|
|
} else if let Ok(id) = Id::from_str(value) {
|
|
Ok(AnyId::Id(id))
|
|
} else {
|
|
Err(serde::de::Error::custom(format!(
|
|
"Invalid AnyId: {}",
|
|
value
|
|
)))
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize)]
|
|
pub struct NullObject;
|
|
|
|
impl JmapObject for NullObject {
|
|
type Property = Null;
|
|
type Element = Null;
|
|
type Id = Null;
|
|
|
|
type Filter = ();
|
|
type Comparator = ();
|
|
|
|
type GetArguments = ();
|
|
type SetArguments<'de> = ();
|
|
type QueryArguments = ();
|
|
type CopyArguments = ();
|
|
type ParseArguments = ();
|
|
|
|
const ID_PROPERTY: Self::Property = Null;
|
|
}
|
|
|
|
impl JmapRight for Null {
|
|
fn all_rights() -> &'static [Self] {
|
|
unreachable!()
|
|
}
|
|
|
|
fn to_acl(&self) -> &'static [Acl] {
|
|
unreachable!()
|
|
}
|
|
}
|
|
|
|
impl FromStr for NullObject {
|
|
type Err = ();
|
|
|
|
fn from_str(_: &str) -> Result<Self, Self::Err> {
|
|
unreachable!()
|
|
}
|
|
}
|
|
|
|
impl JmapObjectId for Null {
|
|
fn as_id(&self) -> Option<Id> {
|
|
unreachable!()
|
|
}
|
|
|
|
fn as_any_id(&self) -> Option<AnyId> {
|
|
unreachable!()
|
|
}
|
|
|
|
fn as_id_ref(&self) -> Option<&str> {
|
|
unreachable!()
|
|
}
|
|
|
|
fn try_set_id(&mut self, _: AnyId) -> bool {
|
|
unreachable!()
|
|
}
|
|
}
|
|
|
|
impl TryFrom<AnyId> for Null {
|
|
type Error = ();
|
|
|
|
fn try_from(_: AnyId) -> Result<Self, Self::Error> {
|
|
unreachable!()
|
|
}
|
|
}
|