talos-sync-types 0.1.6

Canonical data and errors for account-scoped Talos synchronization
Documentation
use base64::{engine::general_purpose::URL_SAFE_NO_PAD, Engine};
use serde::{Deserialize, Serialize};

use crate::{SyncError, SyncErrorCode, SyncResult};

pub const SCHEMA_VERSION: u32 = 1;
pub const PROTOCOL_VERSION: u32 = 1;

#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct SyncScope {
    pub hub_id: String,
    pub account_id: String,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct ComputerAlias {
    pub source_node_id: String,
    pub computer_id: String,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct SyncBinding {
    pub scope: SyncScope,
    pub peer_id: String,
    pub source_user_id: String,
    pub computers: Vec<ComputerAlias>,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum ResourceKind {
    Computer,
    Project,
    Session,
    File,
}

impl ResourceKind {
    pub fn as_str(self) -> &'static str {
        match self {
            Self::Computer => "computer",
            Self::Project => "project",
            Self::Session => "session",
            Self::File => "file",
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(
    tag = "kind",
    rename_all = "camelCase",
    rename_all_fields = "camelCase",
    deny_unknown_fields
)]
pub enum SyncResourceKey {
    Computer { computer_id: String },
    Project { project_id: String },
    Session { session_id: String },
    File { file_id: String },
}

impl SyncResourceKey {
    pub fn kind(&self) -> ResourceKind {
        match self {
            Self::Computer { .. } => ResourceKind::Computer,
            Self::Project { .. } => ResourceKind::Project,
            Self::Session { .. } => ResourceKind::Session,
            Self::File { .. } => ResourceKind::File,
        }
    }

    pub fn id(&self) -> &str {
        match self {
            Self::Computer { computer_id } => computer_id,
            Self::Project { project_id } => project_id,
            Self::Session { session_id } => session_id,
            Self::File { file_id } => file_id,
        }
    }

    pub fn validate(&self) -> SyncResult<()> {
        if self.id().is_empty() || self.id().len() > 128 {
            return Err(SyncError::new(SyncErrorCode::InvalidRequest));
        }
        Ok(())
    }
}

#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct SyncVersion {
    pub version_vector: Vec<u8>,
    pub history_generation: u64,
}

/// Room names are derived from verified account scope; they never grant access.
pub fn room_id(scope: &SyncScope, resource: &SyncResourceKey) -> SyncResult<String> {
    resource.validate()?;
    let digest = sha2::Sha256::digest(serde_json::to_vec(&(scope, resource))?);
    use sha2::Digest;
    Ok(format!("v1.{}", URL_SAFE_NO_PAD.encode(digest)))
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct DocumentJoin {
    pub resource: SyncResourceKey,
    pub history_generation: u64,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct DocumentJoinAccepted {
    pub history_generation: u64,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct SyncResourceSummary {
    pub resource: SyncResourceKey,
    pub computer_id: Option<String>,
    pub version: SyncVersion,
    pub deleted: bool,
}

#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct SyncListParams {
    pub kind: Option<ResourceKind>,
    pub computer_id: Option<String>,
    pub cursor: Option<String>,
    pub limit: Option<u32>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct SyncPage {
    pub resources: Vec<SyncResourceSummary>,
    pub next_cursor: Option<String>,
    pub feed_cursor: String,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct SyncFeedEntry {
    pub resource: SyncResourceKey,
    pub version: SyncVersion,
    pub deleted: bool,
    pub reset: bool,
}