Cómo crear una API de NodeJS sin usar un marco

Node.js es un tiempo de ejecución de JavaScript de código abierto basado en el motor v8 de Chrome que le permite ejecutar código JavaScript fuera de un navegador.

Su modelo de eventos, ecosistema y velocidad han convertido a Node.js en uno de los tiempos de ejecución más buscados y utilizados para aplicaciones del lado del servidor.

La mayoría de los servidores API de Node.js usan Express u otro marco. Sin embargo, también puede crear una API de Node.js simple sin un marco en solo unos pocos pasos.

Paso 1: Configuración de su entorno de desarrollo

Cree un directorio de proyectos y discos compactos en él ejecutando:

mkdir nodejs-api
discos compactos nodejs-api

A continuación, inicialice npm en su proyecto ejecutando:

npm inicializar -y

Esta API CRUD contará con el uso de MongoDB, una base de datos NoSQL, y su popular ODM, mongoose.

Ejecute el siguiente comando para instalar mangosta:

npm Instalar en pc mangosta

A continuación, cree un servidor.js archivo en el directorio raíz de su proyecto y agregue el bloque de código a continuación para crear un servidor:

constante http = requerir("http");
constante servidor = http.createServer((req, res) => {});
servidor.escucha (3000, () => {
consola.Iniciar sesión(`El servidor está funcionando`);
});

Este bloque de código importa el módulo http, un módulo central de Node.js. El módulo http permite que Node.js transfiera datos a través de HTTP. Este módulo contiene los métodos necesarios para crear un servidor.

A continuación, llama al módulo http crearServidor método que crea y devuelve una instancia de un servidor. los crearServidor El método toma una función de devolución de llamada con un objeto de solicitud y respuesta como parámetros.

A continuación, el código llama al escuchar método en la instancia de servidor devuelta. Esto permite que el servidor comience a escuchar el tráfico en el puerto dado. los escuchar El método dispara una devolución de llamada, el segundo argumento, cuando tiene éxito.

Finalmente, cree dos directorios llamados rutas y modelos en el directorio raíz de su proyecto. los rutas carpeta contendrá la lógica de enrutamiento para su API, mientras que modelo contendrá todo lo relacionado con la base de datos.

Paso 2: Conexión de su aplicación a una base de datos

En servidor.js, importar mangosta:

constante mangosta = requerir("mangosta");

Llama a conectar método en mangosta y pase su MongoDB URI como argumento:

mangosta.conectar("MongoDB_URI")

Paso 3: Creación de un modelo de API

Cree una API CRUD para una aplicación de blog simple. En tus modelos carpeta, cree una blogModel.js archivo y agregue el siguiente código a su archivo:

constante mangosta = requerir("mangosta");
constante blogSchema = mangosta. Esquema({
 título: {
 escribe: Cuerda,
 requerido: [verdadero, "El blog debe tener un título."],
 },
 cuerpo: {
 escribe: Cuerda,
 requerido: [verdadero, "El blog debe tener un cuerpo."],
 },
});
módulo.exportaciones = mangosta.modelo("Blog", blogSchema);

El bloque de código anterior crea un modelo de mangosta con dos propiedades y las asigna a una base de datos MongoDB.

Ambas propiedades en este modelo tienen una Cuerda escribir con requerido ajustado a verdadero. Los mensajes de error adjuntos se mostrarán si el cuerpo de una solicitud no contiene ninguna de las propiedades.

La línea final crea y exporta un modelo de mangosta llamando al modelo método en mangosta. Pase el nombre del modelo (Blog) como primer argumento y un esquema (blogSchema) como segundo argumento.

Paso 4: Implementación de enrutamiento en su aplicación

Sin la ayuda de marcos como Express, deberá crear manualmente la lógica para manejar cada solicitud realizada a su API.

Primero, crea un blogRoutes.js archivo en su rutas carpeta, luego importe el modelo de blog:

constante Blog = requerir(../modelos/modelo de blog");

A continuación, cree un asíncrono enrutador función, pasar requerimiento y resolución como parámetros, y exportar la función:

constante enrutador = asíncronofunción (requerimiento, res) {};
módulo.exportaciones = enrutador;

Esta función contendrá toda su lógica de enrutamiento.

A continuación, implementará la lógica de enrutamiento ruta por ruta.

OBTENER Rutas

Agregue el bloque de código a continuación a su enrutador función para implementar la OBTENER controlador de ruta para las solicitudes realizadas a /api/blogs:

// OBTENER: /api/blogs
si (url requerida "/api/blogs"&& método requerido "OBTENER") {
// obtener todos los blogs
constante blogs = esperar Blog.find();
// establecer la estado código ycontenido-escribe
 res.writeHead (200, { "Tipo de contenido": "aplicación/json" });
// enviar datos
resolución.final(JSON.stringificar(blogs));
}

El bloque de código anterior comprueba la URL y método propiedades del objeto de solicitud. A continuación, obtiene todos los blogs de la base de datos a través de la encontrar método en el modelo de mangosta (Blog).

A continuación, llama al cabeza de escritura método en resolución, el objeto de respuesta. Este método envía un encabezado de respuesta con tres argumentos: un código de estado, un mensaje de estado opcional y encabezados. los 200 El código de estado representa una respuesta exitosa y el tipo de contenido para esta llamada a la API se establece en aplicación/json.

Finalmente, cierre la solicitud para asegurarse de que el servidor no se cuelgue llamando al final método en resolución. la llamada a JSON.stringify convierte el blogs objeto a una cadena JSON y pasar eso a la final el método lo devuelve como el cuerpo de la respuesta.

Agregue el bloque de código a continuación a su enrutador función para implementar la OBTENER controlador de ruta para un solo recurso:

// OBTENER: /api/blogs/:id
if (req.url.match(/\\/api\\/blogs\\/([0-9]+)/) && método requerido "OBTENER") {
probar {
// extrae el id de la url
 const id = req.url.split("/")[3];
// obtener el blog de la base de datos
constante blog = esperar Blog.findById (id);
si (blog) {
 res.writeHead (200, { "Tipo de contenido": "aplicación/json" });
resolución.final(JSON.stringificar(Blog));
 } más {
lanzarnuevoError("El blog no existe");
 }
 } captura (error) {
 res.writeHead (404, { "Tipo de contenido": "aplicación/json" });
resolución.final(JSON.stringificar({ mensaje: error }));
 }
}

Este código utiliza el juego método, que toma una expresión regular como argumento, para verificar si la URL coincide con el formato: /api/blogs/.

A continuación, extraiga el identificación propiedad de la URL cadena llamando a su separar método. Este método toma un patrón como argumento (/), divide la cadena según el patrón y devuelve una matriz. El tercer elemento de esa matriz es el identificación.

Finalmente, recupere el documento con la coincidencia identificación de su base de datos. Si existe, envíe un código de respuesta de 200, cierre la solicitud y envíe el blog recuperado. Si no existe, lanza un error y envíalo como respuesta en el bloque catch.

Ruta POST

Agregue el bloque de código a continuación a su función de enrutador para implementar el CORREO controlador de ruta:

// POST: /api/blogs/
si (url requerida "/api/blogs"&& método requerido "CORREO") {
probar {
 dejar cuerpo = "";
// Escuche el evento de datos
 req.en("datos", (pedazo) => {
 cuerpo += trozo.toString();
 });
// Escuchar finalevento
 req.en("final", asíncrono () => {
// Blog creativo
dejar blog = nuevo Blog(JSON.parse (cuerpo));
// Guardar en la base de datos
esperar blog.guardar();
 res.writeHead (200, { "Tipo de contenido": "aplicación/json" });
resolución.final(JSON.stringificar(Blog));
 });
 } captura (error) {
consola.log (error);
 }
}

El objeto de solicitud implementa el Node.js ReadableStream interfaz. Esta corriente emite un datos y un final evento que le da acceso a los datos del cuerpo de la solicitud.

Este código escucha el evento de datos y lo maneja convirtiéndolo en una cadena y concatenándolo al cuerpo variable. En el final controlador de eventos, crea un Blog instancia con la cadena de cuerpo analizada. Luego guarda el nuevo blog, envía el código de estado y el encabezado de contenido y cierra la solicitud.

Poner ruta

Agregue el bloque de código a continuación a su función de enrutador para implementar el PONER controlador de ruta:

// PONER: /api/blogs/:id
if (req.url.match(/\\/api\\/blogs\\/([0-9]+)/) && método requerido "PONER") {
probar {
// extrae el id de la url
 const id = req.url.split("/")[3];
 dejar cuerpo = "";
req.en("datos", (pedazo) => {
 cuerpo += trozo.toString();
 });
 req.en("final", asíncrono () => {
 // Encontrar y actualizardocumento
dejar blog actualizado = esperar Blog.findByIdAndUpdate (id, JSON.parse (cuerpo), {
nuevo: verdadero,
 });
res.writeHead (200, { "Tipo de contenido": "aplicación/json" });
resolución.final(JSON.stringificar(actualizadoBlog));
 });
 } captura (error) {
consola.log (error);
 }
}

El controlador de solicitudes PUT es casi idéntico al CORREO controlador de solicitudes, excepto que extrae el identificación propiedad de la URL para actualizar el blog correspondiente.

ELIMINAR Ruta

Agregue el bloque de código a continuación a la función de su enrutador para implementar su ELIMINAR controlador de ruta:

// ELIMINAR: /api/blogs/:identificación
if (req.url.match(/\\/api\\/blogs\\/([0-9]+)/) && método requerido "ELIMINAR") {
probar {
 const id = req.url.split("/")[3];
// Borrar Blog de base de datos
esperar Blog.findByIdAndDelete (id);
 res.writeHead (200, { "Tipo de contenido": "aplicación/json" });
 res.end (JSON.stringify({mensaje: "Blog eliminado con éxito" }));
 } captura (error) {
 res.writeHead (404, { "Tipo de contenido": "aplicación/json" });
resolución.final(JSON.stringificar({ mensaje: error }));
 }
}

Este bloque de código extrae el identificación desde el URL, elimina el documento con la coincidencia identificación, envía el código de estado y los encabezados y cierra la solicitud.

Finalmente, importa enrutador en tus servidor.js presentar y llamar a su enrutador función, pasando requerimiento y resolución como argumentos:

constante enrutador = requerir("./rutas/blogRutas");
constante servidor = http.createServer((req, res) => {
 enrutador (requerido, res);
});

Esto permite que su servidor intercepte y maneje las solicitudes de manera adecuada.

Puedes encontrar el proyecto terminado en este repositorio GitHub.

Usando un marco Node.js

Aunque es posible crear una API web a mano, puede ser una tarea difícil. Deberá asegurarse de haber cubierto muchos casos extremos y es mejor que su código esté libre de errores.

A lo largo de los años, los desarrolladores han creado marcos como ExpressJS, NestJS, Fastify, etc., para hacerlo mucho más fácil.