todo.rs

//! mon の上に `/api/todos` と一覧のページを載せる例。
//!
//!     cargo run --example todo
//!
//! mon が持つのは土台だけなので、表もルートもこちら側で用意する。

use anyhow::Context;
use axum::Router;
use axum::extract::State;
use axum::http::StatusCode;
use axum::response::Html;
use axum::routing::get;
use chrono::{DateTime, Utc};
use mon::extract::{Json, Path, Query};
use mon::state::AppState;
use mon::{AppError, conf, database, html, log, page, relay, route, session};
use serde::{Deserialize, Serialize};
use sqlx::{FromRow, SqlitePool};
use std::net::SocketAddr;
use std::sync::Arc;
use tokio::net::TcpListener;
use uuid::Uuid;


/// 選び出す列。3 箇所で同じものを使う
const COLUMN: &str = "id, title, done, created_at, updated_at";


#[derive(Debug, Clone, Serialize, FromRow)]
struct Todo {
    id: Uuid,
    title: String,
    done: bool,
    created_at: DateTime<Utc>,
    updated_at: DateTime<Utc>,
}

#[derive(Debug, Deserialize)]
struct CreateTodo {
    title: String,
}

#[derive(Debug, Deserialize)]
struct UpdateTodo {
    title: Option<String>,
    done: Option<bool>,
}

#[derive(Debug, Deserialize)]
struct ListQuery {
    done: Option<bool>,
    limit: Option<i64>,
}


#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let _log = log::start("info,tower_http=debug");

    let conf = conf::load()?;
    let port = conf.port;
    let database = database::connect(&conf.database_url).await?;
    prepare(&database).await?;

    let client = relay::client(&conf).context("中継に使うクライアントを作れません")?;
    let store = session::store(&conf, &database);
    session::prepare(&store).await?;
    session::start_sweep(store.clone(), conf.session_max_age);

    let routes = routes(&conf);
    let state = AppState {
        database,
        client,
        session: store,
        conf: Arc::new(conf),
    };

    let address = SocketAddr::from(([0, 0, 0, 0], port));
    let listener = TcpListener::bind(address)
        .await
        .with_context(|| format!("{address} で待ち受けられません"))?;
    tracing::info!("listening on http://{address}");

    // ConnectInfo を入れると、CLIENT_IP_HEADER がないときに TCP の相手を使える
    let app = route::wrap(routes, state).into_make_service_with_connect_info::<SocketAddr>();

    axum::serve(listener, app).await?;
    Ok(())
}


/// パスは全部こちらで決める。mon は 1 つも取らない
fn routes(conf: &mon::Conf) -> Router<AppState> {
    Router::new()
        .route("/", get(index))
        .route("/api/todos", get(list))
        .route("/api/todos", axum::routing::post(create))
        .route("/api/todos/{id}", get(get_one))
        .route("/api/todos/{id}", axum::routing::patch(update))
        .route("/api/todos/{id}", axum::routing::delete(remove))
        .route("/health", get(route::health))
        .nest("/api/session", session::router())
        .nest("/relay", relay::router())
        .nest_service("/static", route::assets(conf))
        .fallback(page::not_found)
}


async fn prepare(database: &SqlitePool) -> anyhow::Result<()> {
    sqlx::query(
        "create table if not exists todo (\
         id blob primary key not null, title text not null, done integer not null default 0, \
         created_at text not null, updated_at text not null)",
    )
    .execute(database)
    .await
    .context("todo の表を作れません")?;

    Ok(())
}


/// GET / — 保存されているものを並べたページ
async fn index(State(state): State<AppState>) -> Result<Html<String>, AppError> {
    let items = select(&state.database, None, None).await?;
    Ok(Html(html::document("todo", &page(&items))))
}


fn page(items: &[Todo]) -> String {
    let mut out = String::new();
    out.push_str("<h1>todo</h1>");
    out.push_str("<p>SQLite に入っているものを、サーバー側で HTML にして返しています。</p>");

    if items.is_empty() {
        out.push_str(r#"<p class="note">まだ 1 件もありません。</p>"#);
        return out;
    }

    out.push_str("<ul>");
    for item in items {
        let class = if item.done { r#" class="done""# } else { "" };
        out.push_str(&format!("<li{}>{}</li>", class, html::escape(&item.title)));
    }
    out.push_str("</ul>");
    out
}


async fn select(
    database: &SqlitePool,
    done: Option<bool>,
    limit: Option<i64>,
) -> Result<Vec<Todo>, sqlx::Error> {
    let mut sql = format!("select {} from todo", COLUMN);
    if done.is_some() {
        sql.push_str(" where done = ?");
    }
    sql.push_str(" order by created_at limit ?");

    let mut statement = sqlx::query_as::<_, Todo>(&sql);
    if let Some(done) = done {
        statement = statement.bind(done);
    }

    // SQLite では負の limit が「上限なし」を意味する
    statement.bind(limit.unwrap_or(-1)).fetch_all(database).await
}


/// GET /api/todos?done=true&limit=10
async fn list(
    State(state): State<AppState>,
    Query(query): Query<ListQuery>,
) -> Result<Json<Vec<Todo>>, AppError> {
    Ok(Json(select(&state.database, query.done, query.limit).await?))
}


/// POST /api/todos  `{"title": "..."}`
async fn create(
    State(state): State<AppState>,
    Json(body): Json<CreateTodo>,
) -> Result<(StatusCode, Json<Todo>), AppError> {
    let title = validate_title(&body.title)?;
    let now = Utc::now();
    let todo = Todo {
        id: Uuid::now_v7(), // 生成時刻の順に並ぶ UUID
        title,
        done: false,
        created_at: now,
        updated_at: now,
    };

    sqlx::query("insert into todo (id, title, done, created_at, updated_at) values (?, ?, ?, ?, ?)")
        .bind(todo.id)
        .bind(&todo.title)
        .bind(todo.done)
        .bind(todo.created_at)
        .bind(todo.updated_at)
        .execute(&state.database)
        .await?;

    Ok((StatusCode::CREATED, Json(todo)))
}


/// GET /api/todos/{id}
async fn get_one(
    State(state): State<AppState>,
    Path(id): Path<Uuid>,
) -> Result<Json<Todo>, AppError> {
    let found = sqlx::query_as::<_, Todo>(&format!("select {} from todo where id = ?", COLUMN))
        .bind(id)
        .fetch_optional(&state.database)
        .await?;

    found.map(Json).ok_or_else(|| not_found(id))
}


/// PATCH /api/todos/{id}  `{"title": "...", "done": true}`（どちらも省略できる）
async fn update(
    State(state): State<AppState>,
    Path(id): Path<Uuid>,
    Json(body): Json<UpdateTodo>,
) -> Result<Json<Todo>, AppError> {
    let title = body.title.as_deref().map(validate_title).transpose()?;
    let sql = format!(
        "update todo set title = coalesce(?, title), done = coalesce(?, done), updated_at = ? \
         where id = ? returning {}",
        COLUMN
    );

    let updated = sqlx::query_as::<_, Todo>(&sql)
        .bind(title)
        .bind(body.done)
        .bind(Utc::now())
        .bind(id)
        .fetch_optional(&state.database)
        .await?;

    updated.map(Json).ok_or_else(|| not_found(id))
}


/// DELETE /api/todos/{id}
async fn remove(
    State(state): State<AppState>,
    Path(id): Path<Uuid>,
) -> Result<StatusCode, AppError> {
    let result = sqlx::query("delete from todo where id = ?")
        .bind(id)
        .execute(&state.database)
        .await?;

    if result.rows_affected() == 0 {
        return Err(not_found(id));
    }

    Ok(StatusCode::NO_CONTENT)
}


fn not_found(id: Uuid) -> AppError {
    AppError::NotFound(format!("todo {id} は存在しません"))
}


fn validate_title(title: &str) -> Result<String, AppError> {
    let title = title.trim();
    if title.is_empty() {
        return Err(AppError::Validation("title は必須です".to_owned()));
    }

    if title.chars().count() > 200 {
        return Err(AppError::Validation("title は 200 文字以内にしてください".to_owned()));
    }

    Ok(title.to_owned())
}