Aplicaciones con Rullst I · Lección 03 / 14

Rutas: una dirección y una intención

La misma ruta puede recibir peticiones de lectura y creación.

Vamos a descubrir juntos

1
Una petición combina método, ruta, cabeceras y a veces cuerpo. En src/routes.rs, GET /api/missions llama a list y POST en esa ruta llama a create. El enrutador elige el handler; este aplica reglas y produce la respuesta.
2
La raíz / entrega HTML; /app.js y /style.css entregan archivos incorporados al compilar. /api/missions devuelve JSON de la base. No hay carpeta api/missions: una ruta es un contrato de acceso, no necesariamente un archivo.
3
Abre /healthz y /api/missions en el navegador. Revisa estado y Content-Type en la pestaña Red de las herramientas. /healthz confirma que el proceso responde; no comprueba toda la persistencia. GET debe leer sin crear misiones.
4
Detén el servidor, agrega GET /about-lab con una respuesta breve y ejecuta de nuevo. include_str! incorpora archivos; cambios HTML, JS o CSS también requieren recompilar. El kit no incluye recarga automática.

Tu mesa de aplicaciones

El kit incluye la aplicación completa para investigar y modificar. El fragmento explica esta etapa; el editor contiene el archivo indicado. Rullst Academy no compila ni ejecuta este servidor en el navegador.

Archivo para estudiar y modificar

src/routes.rs

.route("/api/missions", get(list).post(create))
.route("/healthz", get(health))

Extrae el kit en una carpeta nueva y abre el terminal junto a Cargo.toml. Usa Rust 1.96+; la primera compilación puede descargar dependencias y tardar. Abre http://127.0.0.1:3010. Detén con Ctrl+C y ejecuta de nuevo tras editar.

cargo test --locked
cargo run --locked

Mis archivos y GitHub

Descarga tu borrador y sustituye el archivo indicado en tu copia extraída. El editor guarda un archivo en este navegador; tu cuenta guarda evaluaciones y XP. El ZIP excluye tus cambios. GitHub envía solo el archivo confirmado; usa Git manual para la aplicación entera, sin bases, respaldos ni secretos.

Enlaces oficiales y siguiente paso

Rullst Core 12.1: rutas

✦

TU MISIÓN

Relacionar método, ruta, handler y respuesta sin confundir ruta con archivo.

Llévatelo contigo

Dibuja el recorrido de una lectura y de una creación. Agrega la ruta de presentación y comprueba que abrirla tres veces no cambia la lista.

A tu ritmo

Mis archivos y GitHub

Cada lección puede convertirse en un registro propio: código, notas o un plan de práctica. Guardar un archivo en GitHub es opcional y no cambia tus XP.

Manual del alumno

El editor y las descargas se abren cuando esta lección esté disponible para tu cuenta. Revisa el acceso indicado abajo o vuelve al mapa de la ruta.

Comprobando tu acceso a esta lección…

Tu camino, paso a paso

Descargar material de la actividad

Descarga el ejemplo de la lección y un cuaderno para tus notas. El ZIP incluye una guía para organizar actividades en uno o varios repositorios. Publicar es opcional; las cuentas habilitadas también pueden usar el botón de envío a GitHub.

Tu archivo de esta lección

Edita el ejemplo o registra lo aprendido. Este espacio no ejecuta código ni corrige respuestas. El borrador se guarda solo en este navegador, separado por cuenta; tú decides cuándo descargar o enviar a GitHub.

El ejemplo puede ser solo un fragmento o una guía. Cambiar la extensión no lo convierte en un programa completo. El ZIP de la actividad contiene material inicial; el botón de archivo editado descarga tu texto.

Mi código o mis notas

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 del archivo

Tu texto se guardará en este navegador al editarlo. En un equipo compartido, borra los borradores al terminar.

El envío directo acepta hasta 8 KiB de texto en un archivo. Usa las descargas y la guía manual para proyectos con varios archivos.

Rutas: una dirección y una intención

Vamos a descubrir juntos

Tu mesa de aplicaciones

Archivo para estudiar y modificar

Enlaces oficiales y siguiente paso

Ahora te toca

Decide antes de ejecutar

Llévatelo contigo

Mis archivos y GitHub

Tu archivo de esta lección

Guardar en mi GitHub

Rullstpetbot