Construir una API que reciba datos en formato JSON y los almacene en una base de datos es uno de los pasos fundamentales para cualquier aplicación web funcional. En Rust, combinando Actix Web y Diesel, puedes lograrlo de forma segura y eficiente, aprovechando la serialización con Serde y herramientas como Postman para probar tus endpoints.

¿Cómo instalar y usar Postman para probar tu API?

Antes de escribir código, necesitas una herramienta para enviar peticiones HTTP a tu servidor. Postman es una aplicación que permite crear requests de cualquier tipo (GET, POST, PUT, DELETE) de manera visual e intuitiva [0:30]. Para instalarlo, basta con ir a su página oficial, descargar la versión correspondiente a tu sistema operativo y seguir el asistente.

Una vez abierto, puedes crear un nuevo request presionando el botón "+". Por ejemplo, un GET apuntando a http://0.0.0.0:9900 te devuelve los datos que ya existen en tu base de datos [1:15]. Esta será la base para verificar que los nuevos registros se crean correctamente.

¿Qué dependencias necesitas para manejar JSON en Rust?

Para que tu servidor en Rust pueda recibir y producir JSON, debes agregar dos crates en tu archivo Cargo.toml [2:05]:

• serde: proporciona los macros Serialize y Deserialize mediante la feature derive.
• serde_json: permite convertir estructuras de Rust a JSON y viceversa.

Estos serializadores transforman tus modelos en representaciones JSON y, al revés, convierten un JSON entrante en una estructura de Rust. En tu archivo de modelos, importas los macros así:

rust use serde::{Deserialize, Serialize};

Luego los aplicas con #[derive(Serialize, Deserialize)] sobre tus structs como Post y PostSimplificado [2:40]. Con esto, ambos modelos pueden convertirse automáticamente a JSON.

¿Cómo crear el endpoint POST para nuevos blog posts?

El endpoint se define con el macro #[post("/new_post")] y una función asíncrona que devuelve un impl Responder [3:20]. La estructura inicial replica la conexión a la base de datos que ya usabas en el GET.

¿Cómo recibir datos JSON en el endpoint?

Para que el endpoint acepte un cuerpo JSON, necesitas un handler struct que actúe como serializador de entrada. En tu archivo de modelos creas:

rust #[derive(Clone, Debug, Serialize, Deserialize)] pub struct NewPostHandler { pub title: String, pub body: String, }

Esta estructura solo contiene title y body porque el slug se genera automáticamente a partir del título [7:00]. En la firma de la función, añades el parámetro item: web::Json<NewPostHandler> para que Actix Web extraiga y deserialice el JSON entrante.

¿Cómo organizar la lógica con funciones reutilizables?

En lugar de acumular toda la lógica dentro del endpoint, puedes implementar funciones directamente sobre tu modelo Post [9:10]:

rust impl Post { pub fn slugify(title: &String) -> String { return title.replace(" ", "-").to_lowercase(); }

pub fn create_post(
    conn: &PgConnection,
    post: &NewPostHandler,
) -> Result<Post, diesel::result::Error> {
    let slug = Post::slugify(&post.title.clone());
    let new_post = NewPost {
        title: &post.title,
        slug: &slug,
        body: &post.body,
    };
    diesel::insert_into(post::table)
        .values(&new_post)
        .get_result(conn)
}

}

La función slugify reemplaza los espacios por guiones y convierte todo a minúsculas, generando un slug válido para URLs [9:45]. La función create_post encapsula la inserción con Diesel, recibiendo la conexión y el handler, y devuelve un Result<Post, Error> para manejar posibles fallos.

En el endpoint, la llamada queda limpia y legible:

rust Post::create_post(&connection, &item)

No olvides registrar el nuevo servicio en tu configuración de Actix Web, junto a los demás endpoints [6:15]. Sin este paso, el servidor responde con un 404.

¿Cómo verificar que todo funciona desde Postman?

Desde Postman, crea un request de tipo POST apuntando a http://0.0.0.0:9900/new_post. En la pestaña Body, selecciona raw con formato JSON e ingresa [8:15]:

{ "title": "Este es un blog en json", "body": "y tiene un body" }

Al presionar Send, el servidor devuelve el nuevo registro con su ID asignado. Si luego ejecutas el GET, verás el post recién creado en la lista completa [11:50].

Con el endpoint POST funcionando y los datos persistiendo en la base de datos, el siguiente paso natural es conectar un frontend. Comparte en los comentarios cómo planeas estructurar tus propios endpoints o qué validaciones adicionales agregarías al recibir los datos.