1.

Creación Del Proyecto

Una vez teniendo el editor de código abierto procederemos a crear una carpeta
en la que inicializaremos un proyecto de NodeJS, ejecutando en una
consola/terminal el siguiente comando:

Nota: si se está usando Visual Studio Code para abrir una terminal se puede utilizar el atajo de teclado
“CTRL + SHIFT + P” luego escribir consola y seleccionar la opción “Create Terminal”

Al ejecutar el comando nos creará un fichero llamado “package.json” en la

carpeta que ubiquemos en la consola.
Este archivo se encargará de listar todos los módulos de npm que instalemos
en nuestro proyecto.
El contenido del archivo es el siguiente:
{
"name": "api_node_express_mongo",
"version": "1.0.0",
"description": "",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"keywords": [],
"author": "",
"license": "ISC"
}
En el archivo se puede observar los siguientes atributos:

Atributo Descripción
Name Nombre del proyecto.
Version Versión del proyecto.
Description Descripción del proyecto.
Main Archivo principal del proyecto.
Scripts Sección para definir comandos para la ejecución de
manera rápida con npm.
Keywords Palabras clave del contenido del proyecto.
Author Autor del proyecto.
License Licencia bajo la cual se distribuye el proyecto.

2. Paquetes NPM

Para instalar paquetes de nodeJS bastará con ejecutar el comando:

En este proyecto estaremos utilizando los siguientes módulos:

Paquete Descripcion
Express Es un módulo de NodeJS para aplicaciones web
backend.
Mongoose Mongoose es una biblioteca de programación orientada a
objetos de JavaScript, que crea una conexión entre
MongoDB y el marco de la aplicación web Express.
Morgan Middleware del registrador de solicitudes HTTP para
node.js.
Cors Cors es un modulo de nodeJS que permite acceder a los
recursos expuestos por el servidor a otros servidores en
distintos servicios.
Dotenv Dotenv es un módulo de dependencia cero que carga
variables de entorno desde un archivo “.env” en process.env
Typescript TypeScript, es un lenguaje de programación fuertemente
tipado que se basa en JavaScript, lo que le brinda mejores
herramientas a cualquier escala..
 Ts-node-dev Módulo de nodeJS que permite reiniciar la ejecución de código
cuando este ha sido modificado.
@types/express Este paquete contiene definiciones de tipos para Express
@types/morgan Este paquete contiene definiciones de tipos para Morgan
@types/cors Este paquete contiene definiciones de tipos para Cors

Tipos De Paquetes
En nodeJS tenemos 2 tipos de Módulos o dependencias:
1) Dependencias de ejecución: Son aquellas que se necesitan para
ejecutar el proyecto en los distintos ambientes.
2) Dependencias de desarrollo: Estas están pensadas como paquetes
únicamente para el proceso de desarrollo y no son necesarios en
producción.

3) Instalar Paquetes Del Proyecto

La instalación de paquetes que se utilizaran se realizara por medio de la

ejecución de 2 comandos:
1) Instalación de dependencias:

2) Instalación de dependencias de desarrollo:

4) Compilador De Typescript
Una vez tengamos instaladas todas las dependencias se procede a inicializar
un proyecto de “Typescript” con el siguiente comando:
 Configurar El Compilador De Typescript

El comando anteriormente ejecutado nos dio como resultado la creación de un archivo

llamado “tsconfig.json” en el cual se encuentran las configuraciones básicas para los
proyectos de TypeScript además la manera comentada de otras configuraciones para
el compilador.
Nosotros haremos uso de las siguientes, con su respectiva clave, valor:

"target": "es6",
"rootDir": "./",
"moduleResolution": "node",
"outDir": "./dist",

Configuración De Scripts De Npm

En el archivo “package.json” será necesario agregar dos entradas en la sección de

scripts:

"scripts": {
"dev": "ts-node-dev index.ts",
"build": "tsc ."
},

5) Carpetas y archivos principales

Una vez tengamos debidamente instaladas las dependencias y configurado el
compilador de TypeScript podemos comenzar a crear los ficheros y carpetas para
comenzar a escribir el código.

> Routes/ index.ts

> Models/ Task.ts (Nombre singular pues representa una instancia a la vez)

> database.ts

> app.ts

> index.ts

6) Creación de la aplicación.

Para iniciar el desarrollo de la aplicación, lo primero que se deberá hacer es crear a

manera de prueba, la aplicación en el archivo “index.ts” con el siguiente código:

import express from "express";

const app = express();
app.listen(3000);
console.log("Server started on port 3000");
Una vez obtenida la respuesta “Server started on port 3000” en la consola

Procedemos a hacer una prueba en el navegador visitando la siguiente ruta

“http://localhost:3000”, para comprobar el correcto funcionamiento del mismo

La respuesta recibir del servidor es un error “Cannot GET /” el cual a pesar de ser un
error no lo es en realidad, esto es debido a que el servidor nos está respondiendo que
no hay ninguna ruta configurada para responder a nuestra petición.

1) Desacoplamiento De La Aplicación De Express En Su Propio Fichero

Para mantener la escalabilidad y el orden en nuestro proyecto, es buena práctica que

tengamos múltiples ficheros para múltiples funciones, como: Rutas, Aplicación,
Modelos de datos, Conexión a la base de datos etc...
En nuestro caso el código referente a nuestra aplicación de “express” estará alojado
en el fichero “app.ts” en el será necesario escribir el siguiente código:

import express from "express";

const app = express();
export default app;

Luego de haber exportado la aplicación en el fichero “app.ts” será necesario

importarlo en el fichero “index.ts” a como se observa en el siguiente código
import app from './app';
const PORT = process.env.PORT || 3000;
app.listen(PORT);
console.log(`Server is listening on port ${PORT}`);
Donde podemos observar que se realiza la importación de “app” desde el
archivo “./app” y la creación de una constante llamada “PORT” que proviene
de una variable de entorno con el mismo nombre.

2) Integración de los Middleware de Express

Integraremos el uso de los middleware “cors”, “morgan”, ”express.json” en

nuestra aplicación con las siguiente líneas de código:
• Primero importamos los middlewares de terceros:
import cors from "cors";
import morgan from "morgan";

• Luego integraremos estos mismos y un tercer middleware el cual es

propio de express a nuestra instancia de la aplicación.
app.use(cors());
app.use(morgan("dev"));
app.use(express.json());

3) Definición de Rutas

El fichero “index.ts” en la carpeta “Routes” será el encargado de definir las

rutas o URL de nuestra aplicación.
Se procederá a crear los distintos Endpoints correspondientes a los distintos
métodos REST de nuestra WebAPI.
Deberemos importará el módulo “Router” de “Express” el cual nos brinda la
funcionalidad de poder crear un enrutador y luego poder integrarlo a nuestra
aplicación definida en otra parte de nuestro proyecto.
import { Router } from "express";
const router = Router();

router.get("/tasks", (req, res) => {

res.send("Hello World");
});

router.post("/tasks", (req, res) => {

res.send("Hello World");
});
export default router;
Una vez definido y exportado nuestros primeros métodos REST será necesario
importarlos en nuestra aplicación de express de la siguiente manera:
Primero importamos “router” de “./Routes” luego le definimos una prefijo
con un string el cual puede ser cualquier valor en este caso “/api”, luego le
pasamos el “router” para que enlacemos esa ruta con ese enrutador
especifico.
import router from "./Routes";
…
app.use('/api',router)

vez importado el “router” en nuestra aplicación procedemos a probar que este

funcione correctamente visitando la dirección “http://localhost:3000/api/tasks”.
Como podemos observar la URL ha cambiado un poco en comparación con la
primer URL que se utilizó para realizar la prueba de funcionamiento, esto es
debido a que se debe agregar el prefijo que definimos en el paso anterior
Al visitar la pagina esta vez podremos observar que esta vez si tenemos una
respuesta

Una vez confirmemos el correcto funcionamiento de nuestra ruta procedemos a

crear el resto de rutas y métodos necesarios para nuestra aplicación con el
siguiente código:
import { Router } from "express";
const router = Router();

router.get("/tasks", (req, res) => {

res.send("obteniendo todas las tareas");
});
router.get("/tasks/:id", (req, res) => {
res.send("Obteniendo una tarea");
});

router.post("/tasks", (req, res) => {

res.send("Creando una tarea");
});

router.put("/tasks/:id", (req, res) => {

res.send("actualizando una tarea");
});

router.delete("/tasks/:id", (req, res) => {

res.send("borrando una tarea");
});
export default router;

4) Creación Del Modelo De Datos

Llegado este punto será necesario crear el modelo de datos que se almacenará
en la base de datos, ya que nuestra aplicación será de tareas nuestro modelo
de datos tendrá la siguiente estructura:
Atributo Tipo de dato Descripción
Title String Título de la tarea
Description String Descripción de la tarea
Is_done Boolean Estado de la tarea
(hecha o no hecha)

Para la creación de nuestro modelo de datos será necesario modificar el fichero

“Tasks.ts” en la carpeta “Models” en este escribiremos el código en el cual será
necesario:
1) importar los modulos “Schema” y “model” de “mongoose”
2) Crear un schema de datos para nuestras tareas
3) Asignar tipos de datos a los atributos de las tareas
4) Definir si se desea que la base datos añada atributos opcionales como la
“versionKey” o como “timestamps”
5) Exportar nuestro esquema a manera de modelo

En el siguiente código podremos observar la definición de cada uno de los

puntos anteriormente abordados.
import { Schema, model } from "mongoose";

const taskSchema = new Schema(

{
title: {
type: String,
required: true,
trim: true,
},
description: {
type: String,
required: true,
trim: true,
},
is_done: {
type: Boolean,
default: false,
},
},
{
versionKey: false,
timestamps: true,
}
);

export default model("Task", taskSchema);

5) Conexión a la base datos

En este paso lo que se pretende es conectar nuestra aplicación a una base de

datos para crear registros de nuestras tareas a través de los métodos REST
que tenemos en la aplicación. Para ello debemos ir al fichero “database.ts” en
la raíz de nuestro proyecto y escribir el código pertinente para:
1) Importar el módulo connect de mongoose.
2) Exportar una variable asíncrona que se encargue de la conexión a la
base de datos.
3) Manejar posibles errores de conexión en la base de datos.
4) Utilizar variables de entorno para realizar la conexión.
import { connect } from "mongoose";
export const dbConnection = async () => {
try {
//Cadena de conexión normal
//mongodb://localhost/databases
const db = await connect(
"mongodb+srv://" +
process.env.DB_USER +
":" +
process.env.DB_PASS +
"@cluster0.tqsdj.mongodb.net/myFirstDatabase?retryWrites=true&w=m
ajority"
);
console.log(db.connection.name);
} catch (err) {
console.error(err);
}
};

6) Variables de entorno
Para cargar las variables de entorno de manera rápida y sencilla será
necesario crear un fichero con la extensión “.env” y cargarlo con el modulo de
nodeJS llamado “dotenv”
Contenido del archivo:
DB_USER="usuario"
DB_PASS="clave"
PORT="5000"

7) Importar la conexión en el “index.ts”

Para importar la conexión y cargar las variables de entorno en el fichero

principal del proyecto será necesario escribir el siguiente código:
import dotenv from "dotenv";
import { dbConnection } from "./database";
dotenv.config();

dbConnection();
 8) CRUD De Métodos Rest En Conjunto Con La Base De Datos
En este punto será necesario hacer la conjunción de los métodos REST, el
modelo de datos y la conexión a la base de datos previamente definidos
Se deber crear:
• Método para listar todas las tareas almacenadas en la base de datos
• Método para crear una tarea
• Método para obtener una tarea en base a su ID
• Método para editar una tarea en base a su ID
• Método para eliminar una tarea en base a su ID
Para ello será necesario alterar los métodos que previamente definimos en el
archivo “index.ts” en la carpeta “Routes”
Dando como resultado un código con funciones asíncronas debido a que
realiza llamadas a la base de datos y debe esperar por la respuesta:

import { Router } from "express";

import Task from "../Models/Task";
const router = Router();
const prefix = "/tasks";

router.get(prefix, async (req, res) => {

const tasks = await Task.find();
console.log(tasks);
res.json(tasks);
});

router.post(prefix, async (req, res) => {

const { title, description } = req.body;
const task = new Task({ title, description });
console.log(task);
task.save();
res.json(task);
});

router.get(prefix + "/:id", async (req, res) => {

try {
const task = await Task.findById(req.params.id);
if (!task) {
return res.status(404).json({ message: "No se encontro la tarea"
});
}
res.json(task);
} catch (error) {
res.status(500).send(error);
}
});

router.put(prefix + "/:id", async (req, res) => {

const updatedTask = await Task.findByIdAndUpdate(req.params.id,
req.body, {
new: true,
});
res.json(updatedTask);
});

router.delete(prefix + "/:id", async (req, res) => {

const deletedTask = await Task.findByIdAndDelete(req.params.id);
res.json(deletedTask);
});

export default router;

Una vez culminado el proceso de escritura de todos los códigos anteriormente

expuestos el proceso de creación de un API Rest con express habrá culminado.