Login con NodeJS, Express y Json Web Token – Definiendo modelos

En este tutorial de programación Android y Javascript voy a intentar explicar como crear una aplicación móvil que permita el Login en Android, haciendo uso de NodeJS y Mysql en la parte del servidor y Json Web Tokens para el manejo de sesiones. Un proyecto fullstack en toda regla. No voy a entrar en detalles de como instalar ni Android Studio, ni Mysql, ni nodeJS y sus dependencias, puesto que existen cientos de tutoriales por ahí. Voy a tratar de ir al grano, explicándolo de la mejor manera posible. Así que, vamos directos al meollo de la cuestión. A grandes rasgos el proyecto consistirá en una aplicación móvil para Android que permita el login de usuarios contra un servidor que ejecuta NodeJs y Express. Una vez autentificado el usuario, le devolverá un token, en formato JWT, que será el encargado de mantener los datos de la sesión.

¿Por donde empezamos?. Por el principio.

1. Así que vamos a crear una carpeta «node-login-android» y desde la línea de comandos, dentro de esa carpeta, con npm init, ponemos la primera piedra del proyecto. Facilitamos los datos que nos pide y ya tendremos creado nuestro archivo package.json
2. Vamos a instalar las dependencias necesarias, con «npm install nombre-de-la-dependencia –save». En este caso haremos uso de: ExpressJS, mysql, basic-auth,bcryptjs,morgan,jsonwebtoken,body-parser, nodemailer, randomstring y sequelize (más que nada porque nunca he trabajado con un orm y algún día había que probarlo). Con ello nuestro package.json debería quedar así:

   {
     "name": "node-login-android",
     "version": "1.0.0",
     "description": "Proyecto de login desde Android",
     "main": "index.js",
     "scripts": {
       "test": "echo "Error: no test specified" && exit 1"
     },
     "author": "Pedro Pablo Moral",
     "license": "ISC",
     "dependencies": {
       "basic-auth": "^1.1.0",
       "bcryptjs": "^2.4.3",
       "body-parser": "^1.17.1",
       "express": "^4.15.2",
       "jsonwebtoken": "^7.3.0",
       "morgan": "^1.8.1",
       "mysql": "^2.13.0",
       "nodemailer": "^3.1.8",
       "randomstring": "^1.1.5",
       "sequelize": "^3.30.4"
     }
   }

3. En cuanto a la estructura del proyecto, tenemos la carpeta base, en mi caso «node-login-android» con la siguiente estructura:
   
   Como veis ya os adelanto que hay que crear una carpeta modelos con un par de archivos (index.js y usuarios.js) que veremos un poco mas adelante.
4. Aunque nuestro ORM se encargará de crear las tablas por nosotros, es necesario crear la base de datos manualmente. Para ello, o bien desde phpmyadmin, MYSQL WorkBench o desde la linea de comandos de MySQL creamos una base de datos. En mi caso «node-login-android».
5. La razón de utilizar sequelize es que nos olvidamos de atacar directamente a la base de datos. Nosotros vamos a crear objetos y vamos a interaccionar con ellos a través de los métodos que nos proporciona Sequelize, que se encargará del trabajo sucio de hablar con la base de datos, permitiéndonos crear código con independencia del motor que usemos. Así que definiremos nuestro modelo «usuarios» de la siguiente forma, en el archivo usuarios.js que hemos creado dentro de la carpeta modelos:

   // Definicion del modelo Usuarios:
   module.exports = function(sequelize, DataTypes) {
       return sequelize.define('Usuarios', {
           username: {
               type: DataTypes.STRING,
               unique: true,
               validate: {
                   notEmpty: {
                       msg: "-> Falta username"
                   }
               },
               unique: {
                   args: true,
                   msg: '-> ya existe un usuario con ese nombre'
               }
           },
           password: {
               type: DataTypes.STRING,
               validate: {
                   notEmpty: {
                       msg: "-> Falta password"
                   }
               }
           },
           email: {
               type: DataTypes.STRING,
               validate: {
                   notEmpty: {
                       msg: "-> Falta email"
                   },
                   isEmail: {
                       msg: "-> Email no válido"
                   }
               },
               unique: {
                   args: true,
                   msg: '-> ya existe un usuario con ese email'
               }
           },
           isAdmin: {
               type: DataTypes.BOOLEAN,
               defaultValue: false
           }
       });
   };

   Si habéis «mantenido relaciones» con bases de datos echaréis de menos un campo único, del tipo id que sea la clave primaria de nuestra tabla. Sequelize se encarga de crearlo por nosotros, al igual que los campos createdAt y updatedAt.

6. Una vez definido el modelo usuarios, hay que añadirlo a nuestro conjunto de modelos. Para ello, en nuestro archivo index.js de la carpeta modelos, colocamos el siguiente código:

   var path = require('path');
   var Sequelize = require('sequelize');
   // Configurar Sequelize para usar mysql
   
   var sequelize = new Sequelize('node-login-android', 'root', '', {
     host: 'localhost',
     dialect: 'mysql',
   
     pool: {
       max: 5,
       min: 0,
       idle: 10000
     }
   
   });
   // Importar modelos.
   
   var Usuarios = sequelize.import(path.join(__dirname,'usuarios'));
   
   // Crear tablas pendientes:
   sequelize.sync({force:true})
   .then(function(err) {
       console.log('Tablas y modelos creados');
     }, function (err) {
       console.log('Algo no fue bien: ', err);
     });
   // Exportar modelos:
   
   exports.Usuarios = Usuarios;

   Creo que el código se entiende bien. Pasamos los parámetros necesarios para que Sequelize conecte con nuestra base de datos, importamos nuestro modelo Usuarios y con sequelize.sync() creamos las tablas necesarias.

7. Y en el index.js de la raíz del proyecto, nos basta colocar, de momento este simple código:

   var modelos = require("./modelos");

Basta con ejecutar nuestro proyecto desde la línea de comandos, con node index.js desde la raíz del proyecto para obtener el resultado deseado. Nuestra tabla está creada con la siguiente estructura:

Hasta aquí la primera parte del proyecto.  Próximamente veremos como implementar la lógica del login, para que compruebe si el usuario y el password coinciden y devuelvan un JWT que permita al usuario permanecer identificado y navegar por las distintas áreas de la aplicación.