 

## ¿Qué es Nodejs?

Tomando la definición del sitio oficial, [Node.js](https://nodejs.org/es/docs/) es un entorno de ejecución para Javascript construido con el motor de Javascript [V8](https://v8.dev/) de Chrome. `Node.js` utiliza un modelo de operaciones [`E/S`](https://es.wikipedia.org/wiki/Perif%C3%A9rico_de_entrada/salida) sin bloqueo y orientado a eventos, que lo hace liviano y eficiente. El ecosistema de paquetes de `Node.js` es [`npm`](https://www.npmjs.com/) y es el ecosistema más grande de librerías de código abierto en el mundo.

El motor `V8` está escrito en C++ y la funcionalidad principal del motor `V8` es compilar código `Javascript` a código de máquina.

Para que esto nos quede un poco mas claro, nosotros podemos utilizar `Javascript` en un sitio web, debido a que los navegadores tienen un `interprete de Javascript` que nos permiten analizar y ejecutar código Javascript. Sin embargo, esto solo ocurre dentro de un navegador, pero, ¿Qué sucede si queremos arrancar código Javascript desde nuestro ordenador?, es aquí cuando Node.js juega un papel importante, porque es quien nos facilita la comunicación de código Javascript a código de máquina para poder ejecutar programas escritos en Javascript en nuestro ordenador.


## Requisitos 

Para dar inicio, nuestro primer requisito es tener instalado [Node.js](https://nodejs.org/es/download/) y [Postman](https://www.postman.com/downloads/), para asegurarnos que tenemos instalado Node.js podemos utilizar nuestra consola `cmd` (si estas en windows) para ver que versión de Node.js y npm tenemos instalada en nuestro ordenador. Abrá el símbolo del sistema y escriba lo siguiente.

```terminal
node -v && npm -v
```

En mi caso la versión de Node.js que estoy utilizando es `v14.15.1` y de npm 
`6.14.8`. Es muy probable que su versión sea distinta a la mía, lo importante es tener instalado Node.js, el sistema de paquetes `npm` se instala por defecto con Nodejs (no tienes que hacer nada).

## Iniciar proyecto

Vamos a crear un directorio para nuestro proyecto, en mi caso lo llamare `express-api`, puedes llamarlo como quieras y ubicarlo en el lugar que más te acomode dentro de tu ordenador, luego entramos al directorio.

```terminal
mkdir express-api && cd express-api\
```

Dentro de nuestro directorio, podemos iniciar nuestro proyecto de Node.js con el comando de npm `init`.

```terminal
npm init --yes
```

Esto nos creara un archivo llamado `package.json`, que es donde estará toda la información de nuestro proyecto. Se verá algo como esto:

```package.json
{
  "name": "express-api",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [
    "express",
    "nodejs"
  ],
  "author": "basmonje",
  "license": "ISC"
}
```

## Instalar dependencias 

Ahora que tenemos nuestro `package.json`, podemos instalar las dependencias necesarias para nuestro proyecto.

- ☑️ [express](https://www.npmjs.com/package/express)
- ☑️ [nodemon](https://www.npmjs.com/package/nodemon)
- ☑️ [morgan](https://www.npmjs.com/package/morgan)
- ☑️ [node-json-db](https://www.npmjs.com/package/node-json-db)

Para instalar las dependencias usaremos el comando `install` seguido por cada dependencia. (Podemos reducir el comando `install` poniendo una letra `i`).

```terminal
npm i express morgan node-json-db
```

Esto creara un directorio `node_modules` (directorio donde se almacenan las dependencias), un archivo `package-lock.json` y nuestro `package.json` se actualizará agregando las nuevas dependencias.

```package.json
{
  "dependencies": {
    "express": "^4.17.1",
    "morgan": "^1.10.0",
    "node-json-db": "^1.1.0"
  }
}
``` 

Si han podido darse cuanta, no agregamos la dependencia `nodemon`, ya que esta dependencia la debemos instalar en modo desarrollo, ya que solo la utilizaremos cuando estemos desarrollando.

Para instalar dependencias de desarrollo debemos agregar `-D`.

```terminal
npm i nodemon -D
```

Nuestro archivo `package.json` quedara algo así.

```package.json
{
  "name": "express-api",
  "version": "1.0.0",
  "description": "primer api rest con nodejs y express",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [
    "express",
    "nodejs"
  ],
  "author": "basmonje",
  "license": "ISC",
  "dependencies": {
    "express": "^4.17.1",
    "morgan": "^1.10.0",
    "node-json-db": "^1.1.0"
  },
  "devDependencies": {
    "nodemon": "^2.0.6"
  }
}

```

## Probando Express

Crearemos el directorio padre quien será el que contenga todo el código, lo llamaremos `src` y dentro de este crearemos un archivo llamado `app.js`.

```terminal
mkdir src && cd src\ && touch app.js
```

Ahora en nuestro archivo `app.js` agregaremos la siguiente configuración de express para arrancar nuestra `API de prueba`. 

```javascript
// Requerimos express
const express = require("express");

// Inicializamos express dentro de una constante `app`
// Declaramos el puerto que queremos utilizar
const app = express();
const port = 4000;

// Rutas
// Desde nuesta app de express
// app estará en escucha del método GET de la raíz 'http://localhost:4000/'
// Cuando exista la solicitud, se enviará la respuesta "Nuestra primera prueba"
app.get("/", (req, res) => {
  res.send({
    message: "Nuestra primera prueba",
  });
});

// Servidor en escucha en puerto 4000
app.listen(port, () => {
  console.log(`Servidor en puerto > ${port}`);
});

```

Ejecute la aplicación con el siguiente comando:

```terminal
node src/app.js
```

A continuación, cargue dentro de `Postman` o de su navegador [http://localhost:4000/](http://localhost:4000/) para ver la salida.

Si todo resulto bien, deberiamos ver algo como esto

![postman-message](assets/posts/servidor-api/peticion-postman.png)

## Nodemon 

Ahora que ya tenemos nuestra base para nuestra API, veremos como manejar nuestro entorno de trabajo de manera mas eficiente. 

Cada vez que hagas un cambio en tu proyecto deberás guardar y arrancar el comando `node src/index.js` para ver los cambios que hemos realizado y esto con el tiempo se vuelve tedioso y repetitivo.

Para esto crearemos nuestro primer `script` llamado `start` dentro de `package.json`.

```package.json
"scripts": {
    "start": "node src/app.js"
},
```

Para iniciar el servidor en nuestra terminal ahora podemos escribir:

```terminal
npm start
```

Como podemos ver, ahora para arrancar nuestro servidor no tenemos que escribir tantas líneas, sin embargo, cada vez que realices un cambio deberás cerrar el proceso y volver a iniciarlo, para mejorar esto utilizaremos la dependencia `nodemon`.

Para hacer uso de `nodemon` agregaremos otro script llamado `dev`, siendo muy similar a la vez anterior con el script `start`.

```package.json
"scripts": {
    "start": "node src/app.js",
    "dev": "nodemon src/app.js"
  },
```

Pero esta vez para arrancar nuestro servidor agregamos el comando `run dev`, como muestra el siguiente comando:

```terminal
npm run dev
```

Ahora que hemos arrancado nuestro servidor con `nodemon` no tendremos necesidad de finalizar nuestro proyecto, los cambios se mostraran de inmediato.

## Configuración de API REST

Comenzaremos con la configuración de nuestra API, primero debemos agregar unos `middlewares` a nuestro archivo `app.js`. Un `middleware` puede ser un método o una función que inicia antes de que se ejecuten las `rutas`.

```javascript
const express = require("express");
const morgan = require("morgan");
// Requerimos nuestro archivo routes.js
const routes = require("./routes");

// Inicializamos servidor express
const app = express();
const port = 4000;

// Middlewares
// Morgan nos mostrará el método de petición de http que estemos realizando
// Como también el statusCode y tiempo transcurrido
// El método express.json()
// Analiza las solicitudes entrantes con cargas JSON
// El método express.urlencoded
// Analiza las solicitudes entrantes con cargas urlencoded
app.use(morgan("dev"));
app.use(express.json());
app.use(express.urlencoded({ urlencoded: false }));

// Rutas
// Creamos una nueva ruta donde mostraremos nuestra api
// http://localhost:4000/user
// http://localhost:4000/user/:id
app.use("/user", routes);

// Servidor en escucha en puerto 4000
app.listen(port, () => {
  console.log(`Servidor en puerto > ${port}`);
});

```

> 📔 Para obtener mas información, leer documentación oficial de express [`express.json()`](http://expressjs.com/es/api.html#express.json) y 
> [`express.urlencoded()`](https://expressjs.com/es/api.html#express.urlencoded)

Creamos un archivo y lo llamamos `routes.js`, luego agregaremos el siguiente código.

```javascript
// Requerimos express
// Inicializamos la función `Router()` dentro de una constante `router`
// Requerimos node-json-db, para crear una base de datos rápida
// Que almacenará nuestros datos dentro de un archivo `json` 

const { Router } = require("express");
const router = Router();
const { JsonDB } = require("node-json-db");
const { Config } = require("node-json-db/dist/lib/JsonDBConfig");

// Configuración de base de datos
const db = new JsonDB(new Config("db", true, false, "/"));

// Creamos nuestra primera ruta con método `POST`
// Esta ruta creara un nuevo usuario
// tomando el id, name y username desde el cuerpo de la solicitud
// que enviaremos a tráves de Postman
// En caso de que no ocurra el registro nos mostrara un mensaje de error
router.post("/", (req, res) => {

  const { id, name, username } = req.body;

  try {
    const path = `/user/${id}`;
    db.push(path, { name, username });
    res.status(200).json({ success: true });
  } catch (error) {
    console.error(error);
    res.status(500).json({
      success: false,
      message: "Usuario no registrado",
    });
  }
});

// Nuestro segundo router con método `GET`
// Mostrara todos los usuarios almacenados
// Si no se encuentra ningun usuario nos mostrara un mensaje
router.get("/", async (req, res) => {
  try {
    const data = await db.getData("/user");
    res.status(200).json({
      data,
    });
  } catch (error) {
    console.error(error);
    res
      .status(404)
      .json({ success: false, message: "No se encuentran usuarios" });
  }
});

// Nuestro tercer router con método `GET`
// Buscara un usuario con el 'id' desde los parámetros
// de la ruta, como ejemplo http://localhost/user/1
// Si no existe el usuarios que buscamos
// Nos arroja un mensaje de usuario no encontrado
router.get("/:id", async (req, res) => {
  const id = req.params.id;
  try {
    const data = db.getData(`/user/${id}`);
    res.status(200).json({ success: true, data });
  } catch (error) {
    console.error(error);
    res.status(404).json({ success: false, message: "Usuario no encontrado" });
  }
});

// Nuestro cuarto router con método DELETE
// Buscara un usuario con el id desde los parámetros de la ruta
// De lo contrario nos mostrara un error
router.delete("/:id", (req, res) => {
  const id = req.params.id;
  try {
    db.delete(`/user/${id}`);
    res.status(200).json({ message: "Usuario eliminado correctamente" });
  } catch (error) {
    console.error(error);
  }
});

module.exports = router;

```

## Probando API con Postman

Ahora que ya tenemos nuestro archivo `routes.js`, podemos agregar datos a nuestra API desde `Postman`. 

Dentro de Postman añadimos la url `http://localhost:4000/user` con método `POST`.

Agregamos dentro de nuestra cabecera `"Headers"` la propiedad [`Content-Type`](https://developer.mozilla.org/es/docs/Web/HTTP/Headers/Content-Type) con el valor `application/json`, con esto podremos enviar datos a nuestro servidor como si fuera un formulario de html.

![agregar content](assets/posts/servidor-api/postman-crear-api.png)

Cambiamos de pestaña a `Body` dentro de Postman y seleccionamos la opción `x-www-form-urlencoded`, para comenzar a agregar usuarios.

![agregar usuarios](assets/posts/servidor-api/save-user-postman.png)

➡️ Sin necesidad de cambiar de ruta y cambiando solo el método a `GET` ya podemos ver los datos que hemos agregado.

![todos los usuarios](assets/posts/servidor-api/alluser-postman-user.png)

Acá podemos ver las rutas que podemos manipular.

```rutas
/user     > GET
/user     > POST
/user/:id > GET
/user/:id > DELETE
```

➡️ Obtener usuario por id.

![obtener usuario por id](assets/posts/servidor-api/userbyid-postman.png)

➡️ Eliminar usuario por id.

![obtener usuario por id](assets/posts/servidor-api/delete-postman.png)

Como has visto no es muy difícil crear una API con Express, ahora sólo hace falta ponerlo en práctica.

> Nota 📖: Si quieres obtener mas información de `Express` puedes ver la [documentación oficial](https://expressjs.com/es/)


> Código de este tutorial. [https://github.com/basmonje/api-express](https://github.com/basmonje/api-express)

Cómo crear una API REST con Nodejs y Express