Parte 2 NodeWallet - Configurando as models iniciais e criando uma Autenticação com JWT

Pedro Ramos — Wed, 11 Oct 2023 11:21:17 +0000

Após a criação do projeto e as configurações inicias vamos, finalmente, partir para o desenvolvimento das funcionalidades. Como primeira funcionalidade, pensei na implementação do login (registro e autenticação) com JWT (Json Web Token) para uma maior segurança do projeto.

Primeiro de tudo vamos configurar a migration Usuário, onde vão ser definidos os campos que vão ser criados na tabela.

'use strict';

/** @type {import('sequelize-cli').Migration} */
module.exports = {
  async up (queryInterface, Sequelize) {
    await queryInterface.createTable('Users', {
      id: {
        allowNull: false,
        autoIncrement: true,
        primaryKey: true,
        type: Sequelize.INTEGER,
      },
      username: {
        type: Sequelize.STRING,
        allowNull: false,
      },
      email: {
        type: Sequelize.STRING,
        allowNull: false,
        unique: true
      },
      password: {
        type: Sequelize.STRING,
        allowNull: false,
      },
      createdAt: {
        allowNull: false,
        type: Sequelize.DATE,
      },
      updatedAt: {
        allowNull: false,
        type: Sequelize.DATE,
      }
    })
  },

  async down (queryInterface, Sequelize) {
    await queryInterface.dropTable('users');
  }
};

Aqui é onde os campos da entidade são criados dentro do banco, sendo necessário informar o tipo do campo, se ele pode ser nulo, se ele vai se autocompletar, se é um campo único e tambem se ele é uma chave primária (usada para se relacionar com outras tabelas).

Com a migration criada, vamos partir para a criação da Model, onde vão ser definidos os tipos dos dados e também métodos para a alteração desses mesmos dados

const { Model } = require('sequelize');
const bcrypt = require('bcrypt');

module.exports = (sequelize, DataTypes) => {
    class User extends Model {
        static associate(models) {

        }
    }

    User.init(
        {
            username: DataTypes.STRING,
            email: DataTypes.STRING,
            password: DataTypes.STRING,
        },
        {
            sequelize,
            modelName: 'User',
            hooks: {
                beforeCreate: async(user) => {
                    if(user.password) {
                        const salt = await bcrypt.genSalt(10);
                        user.password = await bcrypt.hash(user.password, salt);
                    }
                },
            },
        }
    );

    return User;
}

Essa é uma estrutura básica de uma Model, onde eu defino os tipos de dados que cada campo pode aceitar e tambem crio uma função que encripta a senha antes de criar o usuário.

Logo depois da model, partimos para a criação do controller, parte que é responsável por receber e processar as requisições feitas através das rotas

const { User } = require('../models');
const bcrypt = require('bcrypt');
const jwt = require('jsonwebtoken');

module.exports = {
    async register(req, res) {
        try {
            const { username, email, password } = req.body;
            const user = await User.create({username, email, password});
            res.status(201).json({user}); 
        } catch (error) {
            console.error(error);
            req.status(500).json({ error: `Internal Server Error` });
        }
    },

    async login(req, res) {
        try {

            const { email, password } = req.body;
            const user = await User.findOne({ where: {email} });

            if(!user) {
                return res.status(404).json({ error: `Invalid email or password` });
            }

            const isPasswordValid = await bcrypt.compare(password, user.password);

            if(!isPasswordValid) {
                return res.status(404).json({ error: `Invalid email or password` });
            }

            const payload = {
                user
            };

            const secretKey = 'yourSecretKey';

            const options = {
                expiresIn: '12h'
            };

            token = jwt.sign(payload, secretKey, options);

            res.status(200).json({ success: `Successful Login`, user: user, token: token });

        } catch (error) {

            console.error(error);
            res.status(500).json({ error: `Internal server error` });

        }
    },
}

E antes de finalizar vamos a criação do arquivo de rotas, nesse projeto eu optei por separar as rotas em diferentes arquivos, como ainda estamos no começo do projeto por agora teremos apenas o arquivo authRoutes.js

const express = require('express');
const router = express.Router();

const UserController = require('../controllers/UserController');

router.post('/register', UserController.register);
router.post('/login', UserController.login);

module.exports = router;

Agora para finalizar, criamos o arquivo principal do projeto, resolvi chamá-lo de index.js.

const express = require('express');
const app = express();
const PORT = process.env.PORT || 3000;

app.use(express.json());

app.use('/auth', require('./routes/authRoutes'));

app.listen(PORT, () => {
    console.log(`Server is running on port ${PORT}`);
})

Assim temos um login completamente funcional, que faz conexão com o banco de dados e tambem faz uso do JWT!

Até a próxima

NodeWallet (projeto NodeJS de uma carteira virtual, usando Node+Express+Postgres)

Pedro Ramos — Tue, 10 Oct 2023 18:04:09 +0000

Após alguns meses afastado da programação, resolvi me dedicar aos estudos novamente, e agora a bola da vez é o NodeJS. Ferramenta na qual eu sempre tive interesse mas nunca coragem de começar a mexer (talvez era só preguiça mesmo). E a partir de agora vocês vão acompanhar minha trajetória de estudo dessa nova linguagem.

Antes de decidir colocar a mão na massa eu comecei a fazer o curso da OneBitCode para desenvolvedores, porem como ja possuo alguma experiência na programação resolvi começar sozinho um projeto de uma Carteira virtual, onde será possivel anotar as suas entradas e saídas de dinheiro, assim, podendo ter um controle maior das finanças (essa é a ideia inicial do projeto, mais para frente quando essas funcionalidades estiverem bem definidas vou implementar alguns gráficos para ter algo mais visual sobre as transações feitas no mês).

Agora vamos ao que interessa, para esse projeto decidir usar o Node com o Express e o Postgress no docker, ferramentas que ao meu ver vão lidar muito bem com a ideia proposta (node para o processamento dos dados no backend, express para as rotas e um banco de dados relacional, onde muitas informações possuem conexões umas com as outras).

Comecei criando a pasta a pasta do projeto, e dentro dela rodei o comando:

npm init -y

para iniciar um projeto node

Logo que o package.json estava criado, reuni alguns pacotes externos nos quais eu vou necessitar durante a criação do projeto, e são eles:

Express
Bcrypt
JWT
Sequelize
Nodemon

Assim que as todas as depêndencias foram instaladas com o npm, parti para a criação do banco de dados. O banco usado em questão é o PostgreSQL por ser um banco de dados relacional e de facil manutenção, porem estou fazendo uso do mesmo via Docker. Para criar um banco de dados PostgreSQL via docker você precisa seguir os seguintes passos

Ter o Docker instalado na sua máquina
Criar a imagem com o comando: docker run --name meu-postgres -e POSTGRES_PASSWORD=minhasenha -p 5432:5432 -d postgres
Conectar-se com o banco pelo comando: docker exec -it meu-postgres psql -U postgres
E crie um banco de dados com o comando CREATE DATABASE e depois insira as informações do passo 2 em uma IDE (como o DBeaver) e seja feliz com seu banco.

Assim que seu projeto estiver iniciado e com o banco criado, rode o comando npm sequelize init para o sequelize criar as estruturas de pastas necessárias.

Agora que o projeto e o banco estão criados, é só partir para o desenvolvimento, e isso fica na parte 2 desse artigo!

Até!

DEV Community: Pedro Ramos

Parte 2 NodeWallet - Configurando as models iniciais e criando uma Autenticação com JWT

NodeWallet (projeto NodeJS de uma carteira virtual, usando Node+Express+Postgres)