monoprotocol 0.2.0

Mono sync protocol reference types and crypto (spec is canonical in spec/)
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

use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};

use crate::content::ContentHash;
use crate::ids::{DeviceId, ObjectId, OperationId};
use crate::version::VersionVector;

/// Periodic full-ish checkpoint (git-like snapshot).
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct StateSnapshot {
    pub object_id: ObjectId,
    pub merkle_root: ContentHash,
    pub version: VersionVector,
    pub blob_ref: ContentHash,
    pub created_at: DateTime<Utc>,
    pub author_device: DeviceId,
}

/// Intent-based mutation between snapshots.
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct StateOperation {
    pub op_id: OperationId,
    pub object_id: ObjectId,
    pub parent_snapshot: Option<ContentHash>,
    pub mutation: OperationKind,
    pub version_after: VersionVector,
    pub created_at: DateTime<Utc>,
    pub author_device: DeviceId,
    pub signature: Vec<u8>,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "snake_case", tag = "kind")]
pub enum OperationKind {
    Upsert { patch_ref: ContentHash },
    Delete,
    HandoffOffer { target_device: DeviceId },
    RevokeDevice { device_id: DeviceId },
    AgentAction { action_type: String, audit_ref: ContentHash },
}

/// Operations + snapshots: replay ops since last snapshot, then compact.
#[derive(Clone, Debug, Default, Serialize, Deserialize)]
pub struct SyncJournal {
    pub latest_snapshot: Option<StateSnapshot>,
    pub operations: Vec<StateOperation>,
}

impl SyncJournal {
    pub fn append_operation(&mut self, op: StateOperation) {
        self.operations.push(op);
    }

    pub fn compact(&mut self, snapshot: StateSnapshot) {
        self.latest_snapshot = Some(snapshot);
        self.operations.clear();
    }
}