Trait TableLogic 

pub trait TableLogic:
    Send
    + Sync
    + 'static {
    type Row: Serialize + DeserializeOwned + Send + Sync;

    // Required methods
    fn name(&self) -> &'static str;
    fn file(&self) -> &'static str;
    fn title(&self) -> &'static str;
    fn schema(&self, ctx: &Context) -> Result<Schema, ApiError>;
    fn validate(
        &self,
        rows: &[Self::Row],
        ctx: &Context,
    ) -> Result<Vec<ValidationError>, ApiError>;

    // Provided methods
    fn parse(&self, text: &str) -> Result<Vec<Self::Row>, ParseError> { ... }
    fn serialize(&self, rows: &[Self::Row]) -> Result<String, Error> { ... }
    fn derive(
        &self,
        _rows: &[Self::Row],
        _ctx: &Context,
    ) -> Result<Vec<Value>, ApiError> { ... }
    fn siblings(&self, _ctx: &Context) -> Result<Value, ApiError> { ... }
}

One table’s per-repository logic.

parse and serialize default to plain JSONL, so a table whose row type serializes the way it is stored implements neither. derive and siblings default to nothing, so a table with no derived values and no cross-table data implements neither.

Required Associated Types

type Row: Serialize + DeserializeOwned + Send + Sync

Required Methods

fn name(&self) -> &'static str

The route segment and ?table= value, such as books. The names app, health, shutdown, and stop are reserved: the first three are control endpoints and the fourth is the stop subcommand, which clap takes before the positional table name.

fn file(&self) -> &'static str

The file under Data/, such as Books.jsonl.

It is a bare file name: no directory separators, nothing absolute, and not . or ... Building a crate::Server over a table that names anything else panics. It must exist before the editor can open the table; the editor edits a table, it does not create one.

fn title(&self) -> &'static str

The heading the shell shows, such as Books.

fn schema(&self, ctx: &Context) -> Result<Schema, ApiError>

Rebuilt on every read, so sibling-derived options and widths are current.

fn validate( &self, rows: &[Self::Row], ctx: &Context, ) -> Result<Vec<ValidationError>, ApiError>

Problems with the rows, each reported against the row’s one-based position in the set. A write is not refused because of them: the editor persists what it is given and shows the errors beside the cells.

Provided Methods

fn parse(&self, text: &str) -> Result<Vec<Self::Row>, ParseError>

fn serialize(&self, rows: &[Self::Row]) -> Result<String, Error>

Examples found in repository

examples/library/main.rs (line 982)

    fn lend(fields: &Fields, args: &ViewArgs, ctx: &Context) -> Result<String, ApiError> {
        let title = args.get_or("title", "");
        let borrower = fields.text("borrower");
        let days = fields.integer("days")?;
        let from = fields.date("from")?;
        let condition = fields.text("condition").to_lowercase();

        if borrower.is_empty() {
            return Err(ApiError::bad_request("a loan needs a borrower"));
        }
        if days < 1 {
            return Err(ApiError::bad_request("a loan is at least one day long"));
        }
        let start = days_from_civil(from).ok_or_else(|| {
            ApiError::bad_request(format!("{from} is not a date in the calendar"))
        })?;
        let due = civil_from_days(start + days);

        let mut books: Vec<Book> = ctx.rows(BOOKS_FILE)?;
        let book = books
            .iter_mut()
            .find(|b| b.title == title)
            .ok_or_else(|| ApiError::bad_request(format!("no book is called \"{title}\"")))?;
        if book.lent.unwrap_or(false) {
            return Err(ApiError::bad_request(format!("\"{title}\" is already out")));
        }
        book.lent = Some(true);
        book.due = due.clone();
        book.notes = format!("Lent to {borrower} on {from}, {condition}.");

        let problems = Books.validate(&books, ctx)?;
        if let Some(first) = problems.first() {
            return Err(ApiError::bad_request(format!(
                "the loan would leave row {} in a state the table refuses: {}",
                first.line, first.message
            )));
        }

        let text = Books
            .serialize(&books)
            .map_err(|e| ApiError::server(format!("could not serialize {BOOKS_FILE}: {e}")))?;
        ctx.write(BOOKS_FILE, &text)?;

        Ok(format!("\"{title}\" is out to {borrower} until {due}."))
    }

fn derive( &self, _rows: &[Self::Row], _ctx: &Context, ) -> Result<Vec<Value>, ApiError>

Values the editor displays but does not store, parallelling rows index for index. A computed column reads one of the keys of each row’s object through its from.

fn siblings(&self, _ctx: &Context) -> Result<Value, ApiError>

Cross-table data a bespoke editor needs. The schema-driven editor ignores it.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors