che-rest 0.4.0

Typed REST framework and project tooling for che-orm applications
Documentation
//! Run: cargo run --features sync-http --example model_sync
#[path = "model_sync/support.rs"]
mod notes;

use che_orm::ModelRole;
use che_orm::Uuid;
use che_rest::{
    Server,
    sync_http::{RestModelTransport, RestResource},
};
use che_sync::ModelLogClient;
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let (state, token) = notes::demo_state().await?;
    let router = Server::new(state).install(notes::apps()).build().await?;
    let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await?;
    let base = format!("http://{}/api", listener.local_addr()?);
    let server = tokio::spawn(async move { axum::serve(listener, router).await });
    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", format!("Token {token}").parse()?);
    let http = reqwest::Client::builder()
        .default_headers(headers)
        .build()?;
    let transport = || {
        RestModelTransport::new(
            &base,
            http.clone(),
            vec![RestResource::new::<notes::Note, notes::NoteSerializer>("notes").unwrap()],
        )
    };
    let a = ModelLogClient::open(
        notes::database(ModelRole::Client).await?,
        notes::registry(ModelRole::Client),
    )
    .await?;
    let b = ModelLogClient::open(
        notes::database(ModelRole::Client).await?,
        notes::registry(ModelRole::Client),
    )
    .await?;
    let device_a = a.engine(transport()?);
    let device_b = b.engine(transport()?);
    device_a.pull().await?;
    device_b.pull().await?;
    let mut note = notes::Note {
        id: Uuid::now_v7(),
        title: "draft".into(),
        done: false,
        document: Some(che_orm::JsonField(json!({"labels":["offline"]}))),
        number: i64::MAX,
    };
    // The sync facade can create a record; Database::save only updates existing rows.
    a.save(&note).await?;
    for n in 0..10 {
        note.title = format!("offline draft {n}");
        note = a
            .database()
            .save(&note)
            .await?
            .ok_or("offline note was deleted")?;
    }
    assert_eq!(device_a.flush().await?.accepted_operations, 1);
    device_b.pull().await?;
    let mut other = b.database().get::<notes::Note>(note.id).await?.unwrap();
    note.title = "edited by A".into();
    other.done = true;
    a.database()
        .save(&note)
        .await?
        .ok_or("device A note was deleted")?;
    b.database()
        .save(&other)
        .await?
        .ok_or("device B note was deleted")?;
    device_a.flush().await?;
    device_b.pull().await?;
    device_b.flush().await?;
    device_a.pull().await?;
    let merged = a.database().get::<notes::Note>(note.id).await?.unwrap();
    assert_eq!(merged.title, "edited by A");
    assert!(merged.done);
    assert!(a.conflicts().await?.is_empty());
    assert!(b.conflicts().await?.is_empty());
    println!("Ten offline edits became one POST; independent device edits merged: {merged:?}");
    a.delete::<notes::Note>(note.id).await?;
    device_a.flush().await?;
    device_b.pull().await?;
    assert!(b.database().get::<notes::Note>(note.id).await?.is_none());
    println!("Deletion reached device B through the per-model journal.");
    server.abort();
    Ok(())
}