Models

use rustique::prelude::*;
use chrono::NaiveDateTime;

#[rustique::model(table = "flights", timestamps, soft_deletes)]
#[derive(Debug, Clone, Default)]
pub struct Flight {
    pub id: i64,
    pub name: String,
    pub airline_id: i64,
    pub departed_at: Option<NaiveDateTime>,
    pub created_at: Option<NaiveDateTime>,
    pub updated_at: Option<NaiveDateTime>,
    pub deleted_at: Option<NaiveDateTime>,
}

#[rustique::model(table = "order_lines", incrementing = false)]
#[derive(Debug, Clone, Default)]
pub struct OrderLine {
    #[rustique(primary_key)]
    pub order_no: i64,
    #[rustique(primary_key)]
    pub line_no: i64,
    pub sku: String,
}

let line = OrderLine::find(&db, (1001, 2)).await?;   // composite keys take a tuple

#[rustique::model(table = "flights")]
#[derive(Debug, Clone, Default)]
pub struct Flight {
    #[rustique(primary_key, sequence = "FLIGHTS_SEQ")]
    pub id: i64,
}

#[rustique::model(table = "documents", ulid)]   // or `uuid`
#[derive(Debug, Clone, Default)]
pub struct Document {
    pub id: String,                         // `t.ulid("id").primary()`, or `t.uuid(...)`
    pub title: String,
}
let doc = Document::create(&db, Document { title: "Q3".into(), ..Default::default() }).await?;
assert_eq!(doc.id.len(), 26);

let all = Flight::all(&db).await?;                         // Collection<Flight>
let one = Flight::find(&db, 1).await?;                     // Option<Flight>
let one = Flight::find_or_fail(&db, 1).await?;             // Err(Error::NotFound)

let flights = Flight::query()
    .where_(Flight::AIRLINE_ID, "=", 3)
    .order_by(Flight::NAME)
    .limit(10)
    .get(&db).await?;

let first = Flight::query().where_("name", "=", "LH1").first(&db).await?;          // Option
let first = Flight::query().where_("name", "=", "LH1").first_or_fail(&db).await?;  // Err(NotFound)
let by_key = Flight::query().where_key(1).first(&db).await?;
let some = Flight::find_many(&db, [1, 2, 3]).await?;                              // missing keys skipped
let only = Flight::query().where_("name", "=", "LH1").sole(&db).await?;            // Err(NotFound) or Err(MultipleRecords)
let name: Option<String> = Flight::query().where_key(1).value(&db, "name").await?;

// insert
let mut flight = Flight { name: "LH1".into(), airline_id: 3, ..Default::default() };
flight.save(&db).await?;          // INSERT, fills flight.id and the timestamps

// or in one call
let flight = Flight::create(&db, Flight { name: "LH1".into(), ..Default::default() }).await?;

// update
let mut flight = Flight::find_or_fail(&db, 1).await?;
flight.name = "LH2".into();
flight.save(&db).await?;          // UPDATE flights SET name = ?, updated_at = ? WHERE id = ?

let lh1 = || vec![(Flight::NAME, "LH1".into())];
let flight = Flight::first_or_new(&db, lh1(), vec![("seats", 180.into())]).await?;    // not saved
let flight = Flight::first_or_create(&db, lh1(), vec![("seats", 180.into())]).await?; // saved if new
let mut flight = Flight::update_or_create(&db, lh1(), vec![("seats", 200.into())]).await?;

flight.increment(&db, "seats", 10).await?;   // UPDATE ... SET seats = seats + ?, updated_at = ?
flight.decrement(&db, "seats", 5).await?;    // and the field changes too
flight.touch(&db).await?;                    // updated_at = now, then save

let current = flight.fresh(&db).await?;      // Option<Flight>: the row as it is now
flight.refresh(&db).await?;                  // reload the fields in place, dropping unsaved changes
let copy = flight.replicate();               // unsaved clone without key and timestamps

flight.is_dirty();                 // bool
flight.dirty();                    // Vec<(&'static str, Value)> of changed columns
flight.get_original("name");       // Option<&Value> as loaded
flight.exists();                   // loaded from / saved to the database

let changed: u64 = Flight::query()
    .where_("airline_id", "=", 3)
    .update(&db, vec![("airline_id", 4.into())])
    .await?;

#[rustique::model(table = "members")]
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct Member {
    pub id: i64,
    #[rustique(fillable)]
    pub name: String,
    #[rustique(fillable)]
    pub bio: Option<String>,
    pub is_admin: bool, // guarded: not in `MemberFill`
}

member.fill(MemberFill { name: Some("Bea".into()), ..Default::default() });

// From request JSON. Unknown and guarded keys ("is_admin", "id") are rejected;
// `null` clears a nullable column ("bio": null sets bio = None).
let input: MemberFill = serde_json::from_str(body)?;
member.fill(input).save(&db).await?;

let mut flights = vec![Flight { name: "A".into(), ..Default::default() }, Flight { name: "B".into(), ..Default::default() }];
Flight::insert_many(&db, &mut flights).await?;   // all or nothing; fills keys, timestamps, exists

Flight::upsert(&db, &flights, &["name"], &["airline_id"]).await?;   // unique_by, update

flight.delete(&db).await?;                                  // soft delete if soft_deletes, else DELETE
flight.force_delete(&db).await?;                            // always DELETE
Flight::query().where_("airline_id", "=", 3).delete(&db).await?;        // bulk, honours soft deletes
Flight::query().where_("airline_id", "=", 3).force_delete(&db).await?;

Flight::query().with_trashed().get(&db).await?;   // include trashed
Flight::query().only_trashed().get(&db).await?;   // only trashed

flight.trashed();                // bool
flight.restore(&db).await?;      // clears deleted_at and saves

use rustique::{Prunable, Query};

#[rustique::model(table = "sessions")]
#[derive(Debug, Clone, Default)]
pub struct Session {
    pub id: i64,
    pub last_seen: chrono::NaiveDateTime,
}

impl Prunable for Session {
    fn prunable() -> Query<Self> {
        let cutoff = rustique::now() - chrono::Duration::days(30);   // in the application time zone
        Session::query().where_("last_seen", "<", cutoff)
    }
}

let deleted = Session::prune(&db).await?;       // loads them in chunks: `pruning` hook, then force_delete hooks
let deleted = Session::mass_prune(&db).await?;  // one DELETE, no hooks

#[rustique::model(table = "flights", timestamps, soft_deletes,
             created_at = "creation_date", updated_at = "last_update", deleted_at = "removed_on")]
#[derive(Debug, Clone, Default)]
pub struct Flight {
    pub id: i64,
    pub creation_date: Option<NaiveDateTime>,
    pub last_update: Option<NaiveDateTime>,
    pub removed_on: Option<NaiveDateTime>,
}
assert_eq!(<Flight as Model>::CREATED_AT, "creation_date");

rustique::set_timezone(chrono::FixedOffset::east_opt(3600).unwrap());   // or chrono::Local, or chrono_tz::Europe::Bratislava
let now: chrono::NaiveDateTime = rustique::now();                       // wall-clock time in that zone