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.
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:
