Skip to main content

Node JS



Introdução ao Sequelize​

O Sequelize é um ORM (Object-Relational Mapping) para Node.js que facilita a interação com bancos de dados relacionais, como MySQL, PostgreSQL, SQLite e MSSQL. Ele mapeia objetos JavaScript para tabelas no banco de dados e vice-versa, permitindo que os desenvolvedores usem linguagem JavaScript para realizar operações de consulta e manipulação de dados em bancos de dados relacionais. Em resumo, o Sequelize simplifica a interação com bancos de dados relacionais usando JavaScript.


Métodos do Sequelize​

  • .findAll():
    Busca todos os registros de um modelo. Pode ser filtrado com o where. Retorna um array de objetos.

.findOne():
Busca um único registro de um modelo. Pode ser filtrado com o where. Retorna um único objeto ou null se não for encontrado.

  • .create():
    Cria um novo registro no banco de dados. Recebe um objeto com os dados do novo registro. Retorna o objeto criado.

  • .update():
    Atualiza um registro existente no banco de dados. Recebe um objeto com os dados a serem atualizados e um filtro where. Retorna o número de registros atualizados.

  • .destroy():
    Exclui um registro do banco de dados. Pode ser filtrado com o where. Retorna o número de registros excluídos.


Instale o Sequelize e o mysql2:

npm install sequelize mysql2


Para importar e usar o sequelize para estabelece uma conexão com o banco de dados MySQL, podemos fazer assim:

db/conn.js
const { Sequelize } = require('sequelize')

const sequelize = new Sequelize('dbname', 'root', 'SENHA', { 
  host: 'localhost',
  dialect: 'mysql',
})

//try {
//  sequelize.authenticate()
//  console.log('Conectamos com o Sequelize!')
//} catch (error) {
//  console.error('Não foi possível conectar:', error)
//}

module.exports = sequelize

curiosidade
const { Sequelize } = require('sequelize')
const Sequelize = require('sequelize')

Essas duas linhas são usadas para importar a classe Sequelize do pacote sequelize, mas usando diferentes métodos de importação, dependendo de como você pretende usá-la no código.


  • const { Sequelize } = require('sequelize'):
    Neste caso, o Sequelize é extraído diretamente do objeto retornado pelo require('sequelize'). Isso é conhecido como "destructuring assignment" em JavaScript e permite que você importe apenas a parte específica do objeto que você precisa. Isso é útil se você só pretende usar a classe Sequelize do pacote sequelize.

  • const Sequelize = require('sequelize'):
    Aqui, a classe Sequelize é atribuída diretamente à variável Sequelize sem usar a sintaxe de "destructuring assignment". Isso significa que você está importando o objeto sequelize como um todo e atribuindo-o à variável Sequelize. Você pode acessar a classe Sequelize através dessa variável. Isso é útil se você planeja usar várias partes do objeto sequelize em seu código.



Models​

Um modelo (model) no Sequelize é uma representação JavaScript de uma tabela em um banco de dados relacional. Ele define a estrutura da tabela, incluindo os campos (colunas) e os tipos de dados, e fornece métodos para interagir com os dados nessa tabela, como criar, atualizar, ler e excluir registros.


Nos exemplos anteriores nós usamos query para interagir com o Mysql, aqui no Sequelize nós temos que usar os Models para fazer essa interação. Vejamos um exemplo de Model para conectar na

models/User.js
const { DataTypes } = require('sequelize')

const db = require('../db/conn') // Módulo de conexão com o banco de dados!

const User = db.define('User', { // O 'User' é o nome da tabela!
  name: { // Coluna da tabela chamada 'name'!
    type: DataTypes.STRING, // Vai ser do tipo STRING
    allowNull: false, // Não aceita valor null
  },
  occupation: { // Coluna da tabela chamada 'occupation'!
    type: DataTypes.STRING, // Vai ser do tipo STRING
  },
  newsletter: { // Coluna da tabela chamada 'newsletter'!
    type: DataTypes.BOOLEAN, // Vai ser 'true' ou 'false'
  },
})

module.exports = User

Aplicando o model User:

index.js
const conn = require('./db/conn')
const User = require('./models/User') // Importa o módulo de criação da tabela

// Criar tabelas e rodar o app
conn
  .sync()
  .then(() => {
    app.listen(8080)
  })
  .catch((err) => console.log(err))


Inserindo dados​

Para inserir dados, vamos usar o Model criado e usar o método create.

index.js
app.post('/users/create', function (req, res) {
  const name = req.body.name
  const occupation = req.body.occupation
  let newsletter = req.body.newsletter

  if (newsletter === 'on') {
    newsletter = true
  }

  await User.create({ name, occupation, newsletter })

  res.redirect('/')
})

  • await: É usada com funções assíncronas para pausar a execução do código até que a operação assíncrona (neste caso, criar um usuário) seja finalizada.

  • User.create: Assume-se que User é um modelo que representa um usuário em seu aplicativo. A função .create provavelmente é fornecida por um Object-Relational Mapper (ORM) de banco de dados como Sequelize. Essa função é responsável por criar um novo registro de usuário no banco de dados.

  • ({ name, occupation, newsletter }): Esta parte define os dados a serem incluídos para o novo usuário.



Exibindo dados​

Usamos o método fetchAll para ler os dados da tabela (também requer o Model).

index.js

app.get('/', function (req, res) {
  User.findAll({ raw: true }) // Usa o 'raw: true' porque ele lima bastante "sujeira" que seria entregue. | 'User.' é a var que recebe o model da tabela User
    .then((users) => { // pega o que o usuário digitar e salva na var 'users'
      console.log(users)
      res.render('home', { users: users }) // home é 'home.handlebars'. o primeiro 'users' recebe o objeto (json) chamados 'users' que será usado no home.handlebars
    })
    .catch((err) => console.log(err))
})


Usando WHERE​

A cláusula where é geralmente usada dentro do objeto de opções passado para métodos como findAll, findOne, update e destroy. Ela recebe um objeto onde as chaves representam os nomes das colunas e os valores representam as condições que você deseja combinar.

index.js
Model.findAll({ 
  where: {
    // Suas condições aqui
    coluna1: valor1,
    coluna2: {
      // Operadores para condições complexas (opcional)
    }
  }
})


O Sequelize fornece vários operadores para construir condições sofisticadas dentro da cláusula where. Aqui estão alguns dos mais usados:

  • eq: Igual a (coluna1: { eq: valor1 })
  • ne: Diferente de (coluna1: { ne: valor1 })
  • gt: Maior que (coluna1: { gt: valor1 })
  • lt: Menor que (coluna1: { lt: valor1 })
  • gte: Maior ou igual a (coluna1: { gte: valor1 })
  • lte: Menor ou igual a (coluna1: { lte: valor1 })
  • like: Realiza uma correspondência parcial de string (coluna1: { like: '%termo de pesquisa%' })
  • in: Verifica se um valor está dentro de uma lista específica (coluna1: { in: [valor1, valor2] })
  • and, or: Combinar várias condições (where: { and: [{}, {}] })

index.js
app.get('/users/:id', function (req, res) {
  const id = req.params.id

  User.findOne({ // model 'User'
    raw: true,
    where: {     // Aqui vai o 'where'
      id: id,    // nesse caso usa o operador igual 'eq'
    },
  })
    .then((user) => {
      console.log(user)
      res.render('userview', { user })
    })
    .catch((err) => console.log(err))
})

index.js
Model.findAll({ // model 'User'
  where: {
    id: { gt: 5 },
    idade: { lt: 30 }
  }
})


Removendo itens​

Para remover um item da tabela vamos usar o método destroy (também requer o Model).

index.js
Model.destroy({     // model 'User'
  where: { // Condição para remover os itens
    id: id, // Exemplo: remover item com ID específico
  },
});



Editando itens​

Para editar um item da tabela vamos usar o método update (também requer o Model).

index.js
Model.update(data, {
  where: {
    id: id,
  },
}).then(() => {
  console.log('Item editado com sucesso!');
}).catch((err) => {
  console.error('Erro ao editar item:', err);
});


Sync​

No Sequelize, sync ({ force: true }) pode ser usado para forçar a reconstrução das tabelas (todos os dados são perdidos nesse processo).

index.js
conn
  .sync({ force: true })
  .then(() => {
    app.listen(3000)
  })
  .catch((err) => console.log(err))


Relacionamentos​

Em bancos de dados, relacionamentos definem como diferentes tabelas se conectam e interagem. Eles permitem que você organize e acesse dados de forma eficiente.


Tipos de relacionamentos:

  • Um para um (1:1): Uma linha em uma tabela se relaciona com apenas uma linha em outra.
  • Um para muitos (1:N): Uma linha em uma tabela se relaciona com várias linhas em outra.
  • Muitos para muitos (N:N): Várias linhas em uma tabela se relacionam com várias linhas em outra.

Chaves estrangeiras (Foreign Keys):

Uma chave estrangeira é um campo em uma tabela que referencia um campo de chave primária em outra tabela. Ela cria um vínculo entre as duas tabelas.


Considere as tabelas clientes e pedidos:

  • A tabela clientes tem a chave primária id_cliente.
  • A tabela pedidos tem a chave estrangeira id_cliente, que referencia a chave primária da tabela clientes.

Isso significa que cada pedido está associado a um único cliente.


Tipos de Relacionamentos no Sequelize:

  • Belongsto:
    Um relacionamento "pertence a". Uma linha em uma tabela se relaciona com apenas uma linha em outra.

  • HasMany:
    Um relacionamento "tem muitos". Uma linha em uma tabela se relaciona com várias linhas em outra.

  • HasOne:
    Um relacionamento "tem um". Uma linha em uma tabela se relaciona com no máximo uma linha em outra.

  • BelongsToMany:
    Um relacionamento "pertence a muitos". Várias linhas em uma tabela se relacionam com várias linhas em outra.


Comece definindo as models que representam suas tabelas no banco de dados. Cada model deve ter uma propriedade que define a chave primária e a chave estrangeira, se houver.

Exemplo:

models/User.js
// Importe o Sequelize e suas configurações (sequelize, Sequelize) de onde quer que você tenha definido essas configurações

// Crie os modelos User e Pedido
const User = sequelize.define('user', {
  id: {
    type: Sequelize.INTEGER,
    primaryKey: true,
    autoIncrement: true,
  },
  nome: {
    type: Sequelize.STRING,
  },
});

const Pedido = sequelize.define('pedido', {
  id: {
    type: Sequelize.INTEGER,
    primaryKey: true,
    autoIncrement: true,
  },
});
User.hasMany(Pedido);  // Significa User tem muitos Pedidos.
Pedido.belongsto(User); // Significa Pedido está relacionado apenas com um único usuário.

// Exporte os modelos para serem acessíveis em outros lugares da aplicação
module.exports = {
  User,
  Pedido,
};


Fontes​

https://nodejs.org/docs/latest/api/

https://developer.mozilla.org/pt-BR/docs/Learn/JavaScript/Objects/Basics

https://www.udemy.com/course/nodejs-do-zero-a-maestria-com-diversos-projetos/