El primer paso para implementar un proyecto moderno es la construcción de un API REST que podemos consumir desde una aplicación web o móvil.
En el presente tutorial utilizaré las tecnologías Node.js y MongoDB como base de datos para crear un API RESTful. Como framework para Node.js, utilizaré Express.js (versión 4) con MongoDB.
Una API RESTful es un conjunto de operaciones bien definidas que se aplican a todos los recursos de información: HTTP en sí define un conjunto pequeño de operaciones, las más importantes son POST, GET, PUT y DELETE. Con frecuencia estas operaciones se equiparan a las operaciones CRUD en bases de datos (ABMC en castellano: crear,leer,actualizar,borrar) que se requieren para la persistencia de datos, aunque POST no encaja exactamente en este esquema.
1- Crear proyecto e inicializarlo (Para obtener más información y ayuda con este paso ingresar a: Link)
$ mkdir nodejs-apirest $ cd nodejs-apirest$ npm init$ npm install express
El primer código que necesitamos modificar en una aplicación basada en Node.js es el archivo package.json. Éste archivo nos indica que dependencias vamos a utilizar en ella. Este archivo va en el directorio raíz de la aplicación:
{
"name": "nodejs-apirest",
"version": "1.0.0",
"dependencies": {
"body-parser": "~1.13.2",
"express": "~4.13.1",
"method-override": "^2.1.2",
"mongoose": "~3.6.11"
}
}
Posteriormente debemos de descargar las dependencias:
$ npm install
2- Servidor Node.js
Ahora deben de crear el archivo app.js (en la raíz del proyecto) y dejarlo así:
var express = require('express');
var bodyParser = require('body-parser');
var mongoose = require('mongoose');
var methodOverride = require("method-override");
var app = express();
// Middlewares
app.use(bodyParser.urlencoded({ extended: false }));
app.use(bodyParser.json());
app.use(methodOverride());
var router = express.Router();
// Index
router.get('/', function(req, res) {
res.send("Hola Mundo - www.programacion.com.py");
});
app.use(router);
// Start server
app.listen(3000, function() {
console.log("Node server running on http://localhost:3000");
});
Explicación de que hace el código:
-bodyParser: Permite parsear JSON.
-methodOverride: Permite implementar y personalizar métodos HTTP.
Para ejecutar dicho código sólo tienes que escribir en consola lo siguiente y abrir un navegador con la url http://localhost:3000
$ node app.js
3- Crear modelo
Seguimos con la parte de la creación del modelo, utilizaremos Mongoose. Utilizaremos MongoDB: es la base de datos NoSQL líder y permite a las empresas ser más ágiles y escalables.
Para este tutorial crearemos una base de datos de clientes, para eso creamos el modelo cliente (models/client.js):
var mongoose = require('mongoose');
var Schema = mongoose.Schema;
var clientSchema = new Schema({
name: { type: String },
email: { type: String },
genre: { type: String, enum: ['male', 'female'] }
});
module.exports = mongoose.model('Client', clientSchema);
Con esto ya podemos implementar la conexión a la base de datos en el archivo app.js añadiendo las siguientes líneas:
mongoose.connect('mongodb://localhost/clients', function(err, res) {
if(err) throw err;
console.log('Connected to Database');
});
Para que todo lo que está arriba funcione en nuestro entorno local, necesitamos tener instalado MongoDB, para eso ingresar a la: documentación oficial.
Ya tenemos todo configurado y listo para guardar y utilizar los datos, sólo nos queda crear las rutas que definirán las llamadas a la API.
3- Crear controlador
Seguimos con la parte de la creación del controlador (controllers/client.js):
var mongoose = require('mongoose');
var Client = mongoose.model('Client');
//GET - Return all registers
exports.findAll = function(req, res) {
Client.find(function(err, clients) {
if(err) res.send(500, err.message);
console.log('GET /clients')
res.status(200).jsonp(clients);
});
};
//GET - Return a register with specified ID
exports.findById = function(req, res) {
Client.findById(req.params.id, function(err, client) {
if(err) return res.send(500, err.message);
console.log('GET /clients/' + req.params.id);
res.status(200).jsonp(client);
});
};
//POST - Insert a new register
exports.add = function(req, res) {
console.log('POST');
console.log(req.body);
var client = new Client({
name: req.body.name,
email: req.body.email,
genre: req.body.genre
});
client.save(function(err, client) {
if(err) return res.send(500, err.message);
res.status(200).jsonp(client);
});
};
//PUT - Update a register already exists
exports.update = function(req, res) {
Client.findById(req.params.id, function(err, client) {
client.name = req.body.name;
client.email = req.body.email;
client.genre = req.body.genre;
client.save(function(err) {
if(err) return res.send(500, err.message);
res.status(200).jsonp(client);
});
});
};
//DELETE - Delete a register with specified ID
exports.delete = function(req, res) {
Client.findById(req.params.id, function(err, client) {
client.remove(function(err) {
if(err) return res.send(500, err.message);
res.json({ message: 'Successfully deleted' });
});
});
};
Ahora tenemos que unir estas funciones del controlador a las peticiones que serán nuestras llamadas desde el API. Para eso debemos de editar el archivo app.js y declaramos las rutas, el archivo queda así:
var express = require('express');
var bodyParser = require('body-parser');
var mongoose = require('mongoose');
var methodOverride = require("method-override");
var app = express();
// Connection to DB
mongoose.connect('mongodb://localhost/clients', function(err, res) {
if(err) throw err;
console.log('Connected to Database');
});
// Middlewares
app.use(bodyParser.urlencoded({ extended: false }));
app.use(bodyParser.json());
app.use(methodOverride());
// Import Models and Controllers
var models = require('./models/client')(app, mongoose);
var ClientCtrl = require('./controllers/clients');
var router = express.Router();
// Index - Route
router.get('/', function(req, res) {
res.send("Hola Mundo - www.programacion.com.py");
});
app.use(router);
// API routes
var api = express.Router();
api.route('/clients')
.get(ClientCtrl.findAll)
.post(ClientCtrl.add);
api.route('/clients/:id')
.get(ClientCtrl.findById)
.put(ClientCtrl.update)
.delete(ClientCtrl.delete);
app.use('/api', api);
// Start server
app.listen(3000, function() {
console.log("Node server running on http://localhost:3000");
});
4- Probar
A continuación voy a utilizar una extensión de Google Chrome llamada Postman para probar el API.
Antes de probarlo, debemos tener mongodb y el servidor node.js de nuestra app corriendo. Una vez hecho esto introducimos los siguientes datos para hacer una llamada POST que almacene un registro en la base de datos.
Method: POST URL: http://localhost:3000/api/clients Body, utilizando "X-www-form-urlencoded":
Luego pulsamos send, el resultado debe ser el siguiente:
Ahora vamos a comprobar que se ha guardado correctamente, para eso podemos enviar un request GET, a la url: http://localhost:3000/api/clients, el resultado debe de ser:
Como pueden observar hay un registro con el id 5846ace82d6973ec1c000006, podemos recuperar ese registro enviando un request GET, a la url: http://localhost:3000/api/clients/5846ace82d6973ec1c000006 , el resultado debe de ser:
Ahora vamos a probar editar el registro con el id 5846ace82d6973ec1c000006, para eso enviamos un request PUT, a la url: http://localhost:3000/api/clients/5846ace82d6973ec1c000006, el resultado debe de ser:
Por último vamos a probar borrar el registro con el id 5846ace82d6973ec1c000006, para eso enviamos un request DELETE, a la url: http://localhost:3000/api/clients/5846ace82d6973ec1c000006, el resultado debe de ser:
Con esto tendríamos el funcionamiento básico de un API RESTful con Node.js y MongoDB. Como puedes ver es bastante sencillo ya que se utiliza Javascript, como lenguaje de servidor (Node), como formato de datos (JSON) y como base de datos (MongoDB).
Descargar proyecto completo:
