magic_sync 0.1.1

Keeps partial copies of PostgreSQL tables on SQLite replicas — offline-first, by comparing what each replica holds with what it should hold
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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

//! Every attribute, on every kind of table, in one build.

use chrono::{DateTime, NaiveDateTime, Utc};
use uuid::Uuid;

type Cents = i64;

/// Written on the server; read through a view; kept by a replica that still
/// points at a row; with columns one side has and the row leaves out.
#[derive(sqlx::FromRow, Clone, magic_sync::Row)]
#[row(
    table = "products",
    schema = "shop",
    mirror = "catalog",
    sync = "assigned(store_id)",
    active = "shop.live_products",
    retired = "retired_at",
    unmirrored = "archived_at, notes"
)]
pub struct Product {
    pub id: Uuid,
    pub store_id: Uuid,
    pub r#type: String,
    #[sqlx(rename = "Display Name")]
    pub display_name: String,
    pub price: Cents,
    #[row(generated)]
    pub search: Option<String>,
    #[sqlx(skip)]
    pub cached: bool,
    pub updated_at: DateTime<Utc>,
}

/// Its creation, flattened into rows that share it.
#[derive(sqlx::FromRow, Clone, magic_sync::Columns)]
pub struct Stamps {
    #[row(created)]
    pub created_at: NaiveDateTime,
}

/// A replica's reports, keyed by the replica: editable, newest wins.
#[derive(sqlx::FromRow, Clone, magic_sync::Row)]
#[row(
    table = "readings",
    schema = "fleet",
    mirror = "record",
    key = "replica_id, sensor, seq",
    origin = "replica_id"
)]
pub struct Reading {
    pub replica_id: Uuid,
    pub sensor: i16,
    pub seq: i32,
    pub value: f64,
    #[row(version)]
    pub at: i64,
    #[sqlx(flatten)]
    pub stamps: Stamps,
}

/// Written on both sides, column by column.
#[derive(sqlx::FromRow, Clone, magic_sync::Row)]
#[row(table = "tasks", mirror = "both", sync = "grouped(members = crew_tasks, assigned = crews)")]
pub struct Task {
    pub id: Uuid,
    pub title: String,
    #[row(replica_owned)]
    pub done: bool,
    pub updated_at: DateTime<Utc>,
}

/// A replica's setting, whose level the server may wish: carried out only
/// while the replica holds the version the wish is based on.
#[derive(sqlx::FromRow, Clone, magic_sync::Row)]
#[row(
    table = "screens",
    mirror = "setting",
    key = "replica_id, id",
    origin = "replica_id",
    apply = "if_unchanged",
    unmirrored = "installed_at"
)]
pub struct Screen {
    pub replica_id: Uuid,
    pub id: Uuid,
    #[row(desired)]
    pub level: i32,
    #[row(desired)]
    #[sqlx(rename = "Mode")]
    pub mode: Option<String>,
    #[row(version)]
    pub at: NaiveDateTime,
    #[sqlx(flatten)]
    pub stamps: Stamps,
}

/// A row that goes wherever its parent goes.
#[derive(sqlx::FromRow, Clone, magic_sync::Row)]
#[row(table = "task_notes", mirror = "catalog", key = "task_id", sync = "follows(task_id)")]
pub struct TaskNote {
    pub task_id: Uuid,
    pub text: String,
}

fn main() {
    let _ = magic_sync::wire::Codec::<()>::new::<Product, ProductRow>(to, from, None);
}

#[derive(Clone, PartialEq, prost::Message)]
pub struct ProductRow {
    #[prost(string, tag = "1")]
    pub id: String,
}

fn to(_: Product) -> Result<ProductRow, magic_sync::wire::MapError> {
    Err(magic_sync::wire::MapError::new("not this one"))
}

fn from(_: ProductRow) -> Result<Product, magic_sync::wire::MapError> {
    Err(magic_sync::wire::MapError::new("not this one"))
}