Aplicações com Rullst I · Lição 09 / 14

Concluir sem trocar o alvo

A missão pode mudar de posição; seu id permanece.

Vamos descobrir juntos

1
A rota PUT /api/missions/{id}/completion recebe {"done":true} ou false. Path extrai o id e Completion exige bool. A consulta UPDATE inclui WHERE id = ?. Usar a posição da linha na tela alteraria a missão errada após uma reordenação.
2
Definir done=true duas vezes mantém true: o efeito sobre esse estado é idempotente. Alternar done = !done duas vezes voltaria ao começo. A propriedade vem do contrato implementado; escrever PUT no nome não torna qualquer operação idempotente.
3
A aplicação verifica rows_affected. Registro encontrado recebe 204 sem corpo; id inexistente recebe 404 com erro. Não tente ler JSON de uma resposta 204: não há conteúdo para analisar. Uma falha de armazenamento é outra situação e recebe 503.
4
O kit não resolve edição simultânea entre pessoas. Se duas chamadas definirem estados diferentes, a última gravação efetiva prevalece. Versões de registro e controle de concorrência são aprofundamentos; esta limitação deve ficar explícita na entrega.

Sua bancada de aplicações

O kit inclui o aplicativo completo para investigar e modificar. O trecho abaixo explica esta etapa; o editor contém o arquivo indicado. A Rullst Academy não compila nem executa esse servidor no navegador.

Arquivo para estudar e modificar

src/routes.rs

PUT /api/missions/1/completion
{"done":true}

UPDATE missions SET done = ? WHERE id = ?

Extraia o kit numa pasta nova e abra o terminal junto a Cargo.toml. Use Rust 1.96+; o primeiro build pode baixar dependências e demorar. Depois abra http://127.0.0.1:3010. Pare com Ctrl+C e execute novamente após editar.

cargo test --locked
cargo run --locked

Meus arquivos e GitHub

Baixe seu rascunho e substitua o arquivo indicado na sua cópia extraída. O editor guarda um arquivo neste navegador; a conta guarda avaliações e XP. O ZIP não contém suas alterações. GitHub envia só o arquivo confirmado; para o aplicativo completo use Git manual, sem bancos, backups ou segredos.

Links oficiais e próximo passo

✦

SUA MISSÃO

Atualizar por id e distinguir atribuição idempotente de alternância.

Leve com você

No teste HTTP, repita uma conclusão e confira estado e contagem. Depois teste reabrir com false. Explique em palavras próprias a diferença entre definir e alternar.

No seu ritmo

Meus arquivos e GitHub

Toda lição pode virar um registro seu: código, anotações ou um plano de prática. Guardar um arquivo no GitHub é opcional e não altera seu XP.

Manual do aluno

O editor e os downloads abrem quando esta lição estiver liberada para sua conta. Confira o acesso abaixo ou volte ao mapa da trilha.

Conferindo seu acesso à lição…

Seu caminho, passo a passo

Baixar material da atividade

Baixe o exemplo da lição e um caderno para suas anotações. O ZIP inclui um guia para organizar atividades em um ou mais repositórios. Publicar é opcional; contas elegíveis também podem usar o botão de envio ao GitHub.

Seu arquivo desta lição

Edite o exemplo ou registre o que aprendeu. Este espaço não executa código nem corrige respostas. O rascunho é salvo apenas neste navegador, separado por conta; baixar e enviar ao GitHub são ações suas.

O exemplo pode ser apenas um trecho ou roteiro. Mudar a extensão não o transforma em programa completo. O ZIP da atividade contém material inicial; o botão de arquivo editado baixa o seu texto.

Meu código ou minhas anotações

use crate::{
    store::Store,
    validation::{self, Completion, NewMission},
};
use rullst::{
    Router,
    response::{IntoResponse, Response},
    server::{Extension, Json, Path, StatusCode, get},
    web::axum::{
        extract::{DefaultBodyLimit, Request, rejection::JsonRejection},
        middleware::{Next, from_fn},
    },
};
use serde_json::json;

fn error(status: StatusCode, code: &str) -> Response {
    (status, Json(json!({"error": code}))).into_response()
}
fn unavailable() -> Response {
    // No submitted text, SQL, paths or credentials in browser errors or logs.
    eprintln!("mission-board: database operation failed");
    error(StatusCode::SERVICE_UNAVAILABLE, "storage_unavailable")
}

async fn list(Extension(store): Extension<Store>) -> Response {
    match store.list().await {
        Ok(items) => Json(items).into_response(),
        Err(_) => unavailable(),
    }
}
async fn create(
    Extension(store): Extension<Store>,
    input: Result<Json<NewMission>, JsonRejection>,
) -> Response {
    let Json(input) = match input {
        Ok(value) => value,
        Err(e) => return error(e.status(), "invalid_json"),
    };
    let input = match validation::validate(input) {
        Ok(value) => value,
        Err(code) => return error(StatusCode::UNPROCESSABLE_ENTITY, code),
    };
    match store.create(input).await {
        Ok(item) => (StatusCode::CREATED, Json(item)).into_response(),
        Err(_) => unavailable(),
    }
}
async fn complete(
    Extension(store): Extension<Store>,
    Path(id): Path<i64>,
    input: Result<Json<Completion>, JsonRejection>,
) -> Response {
    let Json(input) = match input {
        Ok(value) => value,
        Err(e) => return error(e.status(), "invalid_json"),
    };
    match store.complete(id, input.done).await {
        Ok(true) => StatusCode::NO_CONTENT.into_response(),
        Ok(false) => error(StatusCode::NOT_FOUND, "not_found"),
        Err(_) => unavailable(),
    }
}
#[derive(Clone)]
struct Origins(Vec<String>);

async fn boundary(
    Extension(origins): Extension<Origins>,
    request: Request,
    next: Next,
) -> Response {
    // A loopback exercise, not an authentication/authorization system.
    if request.method() != "GET" && request.method() != "HEAD" {
        if let Some(origin) = request.headers().get("origin") {
            if !origin
                .to_str()
                .is_ok_and(|value| origins.0.iter().any(|allowed| allowed == value))
            {
                return error(StatusCode::FORBIDDEN, "invalid_origin");
            }
        }
    }
    let mut response = next.run(request).await;
    response
        .headers_mut()
        .insert("cache-control", "no-store".parse().unwrap());
    response
        .headers_mut()
        .insert("x-content-type-options", "nosniff".parse().unwrap());
    response.headers_mut().insert("content-security-policy", "default-src 'none'; script-src 'self'; style-src 'self'; connect-src 'self'; base-uri 'none'; frame-ancestors 'none'; form-action 'self'".parse().unwrap());
    response
}

pub fn app(store: Store) -> Router {
    app_with_origins(store, &["http://127.0.0.1:3010", "http://localhost:3010"])
}

pub fn app_with_origins(store: Store, origins: &[&str]) -> Router {
    Router::new()
        .route(
            "/",
            get(|| async { rullst::response::Html(include_str!("../web/index.html")) }),
        )
        .route(
            "/app.js",
            get(|| async {
                (
                    [("content-type", "text/javascript; charset=utf-8")],
                    include_str!("../web/app.js"),
                )
            }),
        )
        .route(
            "/style.css",
            get(|| async {
                (
                    [("content-type", "text/css; charset=utf-8")],
                    include_str!("../web/style.css"),
                )
            }),
        )
        .route("/healthz", get(|| async { Json(json!({"status":"ok"})) }))
        .route("/api/missions", get(list).post(create))
        .route(
            "/api/missions/{id}/completion",
            rullst::web::axum::routing::put(complete),
        )
        .fallback(|| async { error(StatusCode::NOT_FOUND, "not_found") })
        .layer(DefaultBodyLimit::max(4096))
        .layer(from_fn(boundary))
        .layer(Extension(Origins(
            origins.iter().map(|v| (*v).into()).collect(),
        )))
        .layer(Extension(store))
}

Formato do arquivo

Seu texto será guardado neste navegador ao editar. Em computador compartilhado, limpe os rascunhos ao terminar.

O envio direto aceita até 8 KiB de texto em um arquivo. Use o download e o guia manual para projetos com vários arquivos.

Concluir sem trocar o alvo

Vamos descobrir juntos

Sua bancada de aplicações

Arquivo para estudar e modificar

Links oficiais e próximo passo

Agora é a sua vez

Decida antes de executar

Leve com você

Meus arquivos e GitHub

Seu arquivo desta lição

Guardar no meu GitHub

Rullstpetbot