Estructura básica de la aplicación Node.

js
Inicializaremos el proyecto con el comando npm init con el objetivo de crear el package.json
que definirá toda nuestra aplicación.

Cuando el comando termine y tengamos los ficheros básicos creados vamos a montar los
siguientes directorios: /controllers, /models y /routes

 Directorio controllers: aquí guardaremos los ficheros que se encargarán de controlar

cada parte de nuestra aplicación. Tenemos que ser capaces de abstraernos y saber
atomizar la app y en consecuencia crear un controlador para cada una de estas partes.
Los controladores contendrán la lógica de negocio.
 Directorio models: en este directorio vamos a guardar lo que son los modelos de datos
de la aplicación. Si tu aplicación trata sobre discos de música aquí crearemos una
entidad con todas sus propiedades y métodos. Es lo que en Symfony se conoce como
Entidad, en Java una POJO y en PHP una POPO.
 Directorio routers: para hacer más mantenible la exposición de rutas de cada
controlador de tu aplicación en este directorio vamos a guardar la definición de estas
rutas. Piensa que si estas construyendo una API a poco que sigas el modelo de API
Restful como mínimo vas a tener 4 rutas por cada controlador (método GET, método
POST, método PUT y método DELETE)

Una vez creados los directorios mínimos pasaremos a crear el fichero entrypoint (index.js) y el
fichero de configuración de la aplicación.

Es el fichero que hace la función de punto de entrada de nuestra aplicación, el fichero index.js,
vamos a poner la configuración del servidor y a levantarlo.

'use strict'

var app = require('./app');

var port = process.env.PORT || 3000;

app.listen(port, () => {
console.log(`Server running in http://localhost:${port}`);
console.log('Defined routes:');
console.log(' [GET] http://localhost:3000/');
});

Pero… y ¿cómo podemos hacer que este fichero “llame a otros”?

Pues como se ve en la línea número 3 del script haciendo uso del require le estamos indicando
a node que queremos que nos cargue el core de nuestra aplicación, pero con esto no es
suficiente ya que tenemos que indicar algo más que veremos a continuación.

Creamos el archivo app.js:

'use strict'

var express = require('express');

var bodyParser = require('body-parser');
 var app = express();
var api = require('./routes/favorito');

// Convierte una petición recibida (POST-GET...) a objeto JSON

app.use(bodyParser.urlencoded({extended:false}));
app.use(bodyParser.json());
app.use('/api', api);

// Exportar la variable 'app' que contiene express para poder usarla-requerirla en

otros ficheros
module.exports = app;

Este fichero es en el que configuraremos todos los aspectos de nuestra aplicación.

Como puedes leer, en el script estamos cargando el framework express, cargamos el

middleware body-parser y si te fijas en la línea 7 cargamos el archivo de rutas.

A raíz de la pregunta anterior, si queremos hacer que un fichero “llame a otro”, aparte de
hacer uso de la sentencia require en el fichero destino tenemos que exportarlo mediante el
mecanismo de module.exports (última línea)

Una vez exportado ya podremos utilizarlo en cualquier parte de la app siempre y cuando lo
carguemos con require.

Vale, hasta aquí todo correcto. Vamos a ver ahora como organizar un proyecto Node.js con sus
rutas, sus controladores y sus modelos de datos.

Definiendo uno de los controladores de nuestra app

El controlador es el encargado de contener toda la lógica de negocio de nuestra aplicación.
Tiene que actuar como una caja negra, le entran unos datos, los procesa y nos devuelve otros
datos.

Hay varias formas de plantear y crear un controlador, pero para el ámbito organizativo (no
programático) de este artículo vamos a hacer funciones en lugar de clases, solo tenemos un
controlador.

En un archivo llamado álbum.js que guardamos en la carpeta controllers:

'use strict'

function getAlbum(req, res){

var id = req.params.id;
res.status(200).send({
data: id,
});
}

function getAlbums(req, res){

res.status(200).send({
data:albums
});
}
 function saveAlbum(req, res){
var params = req.body;
res.status(200).send({
album: params
});
}

function updateAlbum(req, res){

var params = req.body;
res.status(200).send({
album: params
});
}

function deleteAlbum(req, res){

var id = req.params.id;
res.status(200).send({
data: id,
});
}

module.exports = {
getAlbum,
getAlbums,
saveAlbum,
updateAlbum,
deleteAlbum
}

Fíjate en la estructura y no en el código, de hecho, hace más bien poco o nada.

Este es sería un controlador típico en un modelo de CRUD (Crear, Leer, Actualizar y Borrar; del
original en inglés: Create, Read, Update and Delete) ) en el que implementamos las cuatro
operaciones típicas, lectura de datos, creación, actualización de datos y borrado.

Cada función de este controlador hará una tarea diferente por lo que decimos que serán
funciones atómicas.

Peeeeero lo importante de toda esta película esta al final del script. Fíjate que al igual que
hacíamos en el fichero app.js, en este estamos exportando las funciones que nos interesan
para que puedan ser llamadas desde otro fichero, como por ejemplo desde el fichero de
definición de rutas.

Definir las rutas

Ha llegado el momento de definir las rutas de nuestra aplicación.

Y al igual que en el fichero anterior habíamos creado cuatro funciones (bueno en realidad 5
pero dos de ellas internamente sirven para lo mismo, getAlbum y getAlbums, lectura de datos)
ahora vamos a crear también 4 rutas y cada una de ellas matcheará con un método HTTP
diferente.
Para que no te pierdas este va a ser el esquema de la relación métodos HTTP (API Restful) y
funciones:

 Método GET -> getAlbum() y getAlbums()

 Método POST -> saveAlbum()
 Método PUT -> updateAlbum()
 Método DELETE -> delteAlbum()

Lo más importante y lo primero de todo es crear el fichero album.js en el directorio de /routes:

'use strict'

var express = require('express');

var AlbumController = require('../controllers/album');
var api = express.Router();

api.get('/album/:id', AlbumController.getAlbum);
api.get('/album', AlbumController.getAlbums);
api.post('/album', AlbumController.saveAlbum);
api.put('/album', AlbumController.updateAlbum);
api.delete('/album/:id', AlbumController.deleteAlbum);

module.exports = api;

Mira bien:

Línea número 3: cargamos el framework express.

Línea número 4: cargamos el controlador de álbum.

Línea numero 5: nos traemos el sistema para definir rutas del framework.

Línea 7: definimos una ruta GET para la función getAlbum().

Línea 8: definimos una ruta GET para la función getAlbums().

Línea 9: definimos una ruta POST para la función saveAlbum().

Línea 10: definimos una ruta PUT para la función updateAlbum().

Línea 11: definimos una ruta DELET para la función deleteAlbum().

Y con esto ya tendríamos la estructura básica y el artículo montado sobre como organizar un
proyecto Node.js.

Por supuesto que faltan muchas cosas, de primeras el modelo de datos (eso lo dejaré para
cuando empecemos con MongoDB) pero podríamos meter un directorio para la realización de
test unitarios, otro para las vistas en caso en que quisiéramos ampliar la API… otro para
utilidades, no sé…

El patrón MVC mínimo sería este, a partir de aquí tú ya Feel Free…