Notas

Early return

• Para hacer un retorno rápido, se debe utilizar return dentro de llaves {}

async fn early_return() {
  let uuid = match Uuid::parse_str(&uuid) {
    Ok(uuid) => uuid,
    Err(_) => {
      return Err((StatusCode::BAD_REQUEST, "UUID not valid".to_string()));
    }
  }
  
  // Mas codigo...
}

• El return en el match funciona sin llaves si está al final de la función
• Si es lo último que se va a evaluar

async fn _delete(Path(uuid): Path<String>) -> Result<(), ()> {
    let uuid_result = Uuid::parse_str(&uuid);

    // Sin llaves y "return" si es lo último que se evalua
    match uuid_result {
        Ok(_) => Ok(()),
        Err(_) => Err(()),
    }
}

--> impl IntoResponse vs personalizado

• IntoResponse y personalizado
• Ambos enfoques son conceptualmente "lo mismo" en cuanto al resultado final
• Producen una respuesta HTTP, pero uno es más explícito y detallado que el otro

Personalizado

• Response con tipo personalizado
• Ventaja: Explicita el manejo de errores y éxito, lo que facilita la comprensión del código
• Ideal para controladores que necesitan manejar múltiples escenarios de éxito/fallo
• Inconveniente: Puede ser más detallado de lo necesario para casos simples.
• En este caso, estás devolviendo un Result que puede contener una respuesta Ok o un Err

async fn _handler() -> Result<(), ()> {
    "Hello, world!"
    Ok()
}

-> impl IntoResponse 
// similar a 
-> Result<Json<Vec<BookResponse>>, (StatusCode, Json<Value>)>

-> impl IntoResponse
// similar a 
(Json<Vec<BookResponse>>, (StatusCode, Json<Value>))

impl IntoResponse

• Response con --> impl IntoResponse
• El trait IntoResponse permite que cualquier tipo se convierta en una respuesta HTTP válida
• Cualquier tipo que implemente el trait IntoResponse puede ser retornado
• Ej: un String o un Json
• Ventaja: Más conciso y fácil de usar para respuestas simples
• Inconveniente: Menos explícito en el tipo de datos que se devuelve
• No siempre es obvio qué tipo de respuesta se va a enviar.
• --> impl IntoResponse == Any type

async fn _handler() -> impl IntoResponse {
    "Hello, world!"
}