Skip to main content

zero_client/protocol/
client_schema.rs

1//! The schema a client was built with, sent so zero-cache can check it
2//! against the replica (`clientSchemaSchema` in
3//! `packages/zero-protocol/src/client-schema.ts`).
4
5use super::*;
6use crate::schema::ValueType;
7use crate::strings;
8
9/// `tableSchemaSchema`: each column's `{type}`, and the primary key.
10#[derive(Clone, Debug, PartialEq)]
11pub struct ClientTable {
12    /// In the order they were sent.
13    pub columns: Vec<(String, ValueType)>,
14    pub primary_key: Vec<String>,
15}
16
17#[derive(Clone, Debug, PartialEq, Default)]
18pub struct ClientSchema {
19    /// In the order they were sent.
20    pub tables: Vec<(String, ClientTable)>,
21}
22
23impl JsonCodable for ClientSchema {
24    fn from_json(v: &Value) -> Result<Self> {
25        let names: Vec<&str> = ValueType::ALL.iter().map(|t| t.as_str()).collect();
26        let r = Reader::new(v, "client schema")?;
27        let tables = r.required("tables", |v| {
28            decode::record(v, |t| {
29                let t = Reader::new(t, "table schema")?;
30                Ok(ClientTable {
31                    columns: t.required("columns", |v| {
32                        decode::record(v, |c| {
33                            let c = Reader::new(c, "column schema")?;
34                            c.required("type", |v| {
35                                let name = literal_union(v, &names)?;
36                                Ok(ValueType::parse(name).expect("listed"))
37                            })
38                        })
39                    })?,
40                    primary_key: t.required("primaryKey", decode::strings)?,
41                })
42            })
43        })?;
44        Ok(ClientSchema { tables })
45    }
46
47    fn to_json(&self) -> Value {
48        let tables: Object = self
49            .tables
50            .iter()
51            .map(|(name, t)| {
52                let columns: Object = t
53                    .columns
54                    .iter()
55                    .map(|(c, ty)| (c.clone(), Builder::new().set("type", ty.as_str()).build()))
56                    .collect();
57                let table = Builder::new()
58                    .set("columns", columns)
59                    .set("primaryKey", decode::strings_json(&t.primary_key))
60                    .build();
61                (name.clone(), table)
62            })
63            .collect();
64        Builder::new().set("tables", tables).build()
65    }
66}
67
68impl ClientSchema {
69    /// `normalizeClientSchema`: tables, columns, and each primary key sorted
70    /// by UTF-16 code unit, as JS `sort()` and `<` sort them.
71    pub fn normalized(&self) -> ClientSchema {
72        let mut tables: Vec<(String, ClientTable)> = self
73            .tables
74            .iter()
75            .map(|(name, t)| {
76                let mut columns = t.columns.clone();
77                columns.sort_by(|a, b| strings::utf16(&a.0, &b.0));
78                let mut primary_key = t.primary_key.clone();
79                primary_key.sort_by(|a, b| strings::utf16(a, b));
80                (
81                    name.clone(),
82                    ClientTable {
83                        columns,
84                        primary_key,
85                    },
86                )
87            })
88            .collect();
89        tables.sort_by(|a, b| strings::utf16(&a.0, &b.0));
90        ClientSchema { tables }
91    }
92}