DevOps

Guía Completa de Sequelize en Node.js

Last Updated: 02/01/2025
7 minutos de lectura

Introducción a Sequelize

Sequelize es un ORM (Object-Relational Mapping) para Node.js diseñado para facilitar la interacción con bases de datos relacionales como PostgreSQL, MySQL, MariaDB, SQLite y Microsoft SQL Server. Sequelize permite a los desarrolladores manejar las bases de datos de manera estructurada y eficiente mediante la definición de modelos, asociaciones y la ejecución de operaciones CRUD.

Publicaciones relacionadas

Instalación y Configuración

Para comenzar, asegúrate de tener Node.js instalado junto con un gestor de paquetes como npm o yarn. Instala Sequelize y el cliente adecuado para la base de datos:

bash
npm install sequelize
npm install pg pg-hstore

Si estás utilizando MySQL:

bash
npm install mysql2

Conexión a la Base de Datos

Configura Sequelize para conectarte a tu base de datos. Un ejemplo básico:

javascript
const { Sequelize } = require('sequelize');

const sequelize = new Sequelize('database', 'username', 'password', {
  host: 'localhost',
  dialect: 'postgres', // Cambia según tu base de datos
});

sequelize
  .authenticate()
  .then(() => console.log('Conexión exitosa'))
  .catch((err) => console.error('Error al conectar', err));

Modelos en Sequelize

Definición de Modelos

Los modelos representan tablas en la base de datos. Define un modelo para gestionar los datos de una tabla:

javascript
const { DataTypes } = require('sequelize');

const User = sequelize.define('User', {
  username: {
    type: DataTypes.STRING,
    allowNull: false,
  },
  email: {
    type: DataTypes.STRING,
    allowNull: false,
    unique: true,
  },
  password: {
    type: DataTypes.STRING,
    allowNull: false,
  },
});

module.exports = User;

Tipos de Datos

Sequelize proporciona una amplia variedad de tipos de datos:

  • STRING: Texto corto.
  • TEXT: Texto largo.
  • INTEGER: Números enteros.
  • FLOAT: Números decimales.
  • BOOLEAN: Valores true o false.
  • DATE: Fechas y horas.

Validaciones

Añade validaciones para asegurar la integridad de los datos:

javascript
const Product = sequelize.define('Product', {
  name: {
    type: DataTypes.STRING,
    allowNull: false,
    validate: {
      notEmpty: true,
    },
  },
  price: {
    type: DataTypes.FLOAT,
    allowNull: false,
    validate: {
      isFloat: true,
      min: 0,
    },
  },
});

Migraciones y Sincronización

Migraciones

Las migraciones permiten versionar los cambios en la estructura de la base de datos. Usa Sequelize CLI para generar migraciones:

bash
npx sequelize-cli migration:generate --name nombre-migracion

Sincronización

Sincroniza los modelos con la base de datos:

javascript
sequelize.sync({ force: false }).then(() => {
  console.log('Sincronización completa');
});

Asociaciones entre Modelos

Sequelize admite relaciones entre modelos:

Uno a Uno

javascript
User.hasOne(Profile);
Profile.belongsTo(User);

Uno a Muchos

javascript
User.hasMany(Post);
Post.belongsTo(User);

Muchos a Muchos

javascript
Post.belongsToMany(Tag, { through: 'PostTags' });
Tag.belongsToMany(Post, { through: 'PostTags' });

Consultas y Operaciones CRUD

Creación de Registros

javascript
User.create({ username: 'Juan', email: '[email protected]', password: '1234' });

Lectura de Registros

javascript
User.findAll({ where: { username: 'Juan' } });

Actualización de Registros

javascript
User.update({ email: '[email protected]' }, { where: { username: 'Juan' } });

Eliminación de Registros

javascript
User.destroy({ where: { username: 'Juan' } });

Transacciones

Usa transacciones para garantizar la consistencia de los datos:

javascript
sequelize.transaction(async (t) => {
  const user = await User.create({ username: 'Pedro' }, { transaction: t });
  await Profile.create({ userId: user.id }, { transaction: t });
});

Eager Loading y Lazy Loading

  • Eager Loading: Carga relaciones al mismo tiempo que la consulta principal:
javascript
User.findAll({ include: Profile });
  • Lazy Loading: Carga relaciones bajo demanda:
javascript
const user = await User.findByPk(1);
const profile = await user.getProfile();

Optimización y Buenas Prácticas

  • Define índices en las columnas que se consultan frecuentemente.
  • Evita cargar todos los datos; utiliza paginación.
  • Usa logging: false en la configuración para reducir la verbosidad.

Integración con Express.js

Integra Sequelize en una aplicación Express:

javascript
const express = require('express');
const app = express();
const User = require('./models/User');

app.get('/users', async (req, res) => {
  const users = await User.findAll();
  res.json(users);
});

app.listen(3000, () => console.log('Servidor en ejecución'));

Depuración y Manejo de Errores

  • Maneja errores con bloques try-catch.
  • Usa herramientas como sequelize-cli para depuración avanzada.
javascript
try {
  const users = await User.findAll();
} catch (err) {
  console.error('Error:', err);
}

Recursos Adicionales

Esta guía cubre los conceptos básicos y avanzados para trabajar con Sequelize en Node.js, brindando una base sólida para el desarrollo de aplicaciones robustas y escalables.

Más Informaciones

Sequelize es un ORM (Object-Relational Mapping) para Node.js que facilita la interacción con bases de datos relacionales como MySQL, PostgreSQL, SQLite y MSSQL. Al trabajar con Sequelize, es común encontrarse con la necesidad de utilizar tablas y realizar consultas comunes en bases de datos. Vamos a explorar cómo se pueden manejar las tablas y las consultas comunes usando Sequelize.

En Sequelize, las tablas se representan mediante modelos. Un modelo en Sequelize es una representación de una tabla en la base de datos. Para definir un modelo en Sequelize, primero necesitamos importar el módulo sequelize y luego crear una instancia de Sequelize. Por ejemplo:

javascript
const Sequelize = require('sequelize');
const sequelize = new Sequelize('nombre_base_de_datos', 'usuario', 'contraseña', {
  dialect: 'mysql' // Puede ser 'mysql', 'sqlite', 'postgres', 'mssql'
});

Una vez que tenemos la instancia de Sequelize, podemos definir un modelo utilizando el método define. Por ejemplo, para definir un modelo para una tabla llamada Usuario con columnas id, nombre y edad, podemos hacer lo siguiente:

javascript
const Usuario = sequelize.define('Usuario', {
  id: {
    type: Sequelize.INTEGER,
    primaryKey: true,
    autoIncrement: true
  },
  nombre: {
    type: Sequelize.STRING
  },
  edad: {
    type: Sequelize.INTEGER
  }
});

En este ejemplo, estamos definiendo un modelo llamado Usuario con tres columnas: id, nombre y edad. La columna id es la clave primaria y se autoincrementa automáticamente.

Una vez que hemos definido nuestros modelos, podemos realizar diversas operaciones comunes en la base de datos, como insertar, actualizar, eliminar y consultar datos. A continuación, veremos algunos ejemplos de cómo realizar estas operaciones comunes utilizando Sequelize.

1. Insertar datos:

Para insertar datos en la tabla Usuario, podemos utilizar el método create. Por ejemplo:

javascript
Usuario.create({
  nombre: 'Juan',
  edad: 30
}).then(usuario => {
  console.log('Usuario creado:', usuario.toJSON());
}).catch(error => {
  console.error('Error al crear usuario:', error);
});

Este código insertará un nuevo usuario en la tabla Usuario con el nombre ‘Juan’ y la edad 30.

2. Actualizar datos:

Para actualizar datos en la tabla Usuario, podemos utilizar el método update. Por ejemplo, para actualizar la edad de un usuario con el nombre ‘Juan’, podemos hacer lo siguiente:

javascript
Usuario.update({ edad: 31 }, {
  where: {
    nombre: 'Juan'
  }
}).then(resultado => {
  console.log('Filas actualizadas:', resultado[0]);
}).catch(error => {
  console.error('Error al actualizar usuario:', error);
});

Este código actualizará la edad del usuario con el nombre ‘Juan’ a 31.

3. Eliminar datos:

Para eliminar datos de la tabla Usuario, podemos utilizar el método destroy. Por ejemplo, para eliminar un usuario con el nombre ‘Juan’, podemos hacer lo siguiente:

javascript
Usuario.destroy({
  where: {
    nombre: 'Juan'
  }
}).then(resultado => {
  console.log('Filas eliminadas:', resultado);
}).catch(error => {
  console.error('Error al eliminar usuario:', error);
});

Este código eliminará todos los usuarios con el nombre ‘Juan’ de la tabla Usuario.

4. Consultar datos:

Para consultar datos en la tabla Usuario, podemos utilizar el método findAll. Por ejemplo, para obtener todos los usuarios con una edad mayor o igual a 25, podemos hacer lo siguiente:

javascript
Usuario.findAll({
  where: {
    edad: {
      [Sequelize.Op.gte]: 25
    }
  }
}).then(usuarios => {
  usuarios.forEach(usuario => {
    console.log(usuario.toJSON());
  });
}).catch(error => {
  console.error('Error al consultar usuarios:', error);
});

Este código recuperará todos los usuarios con una edad mayor o igual a 25 de la tabla Usuario.

Estos son solo algunos ejemplos de cómo trabajar con tablas y realizar consultas comunes en una base de datos utilizando Sequelize en Node.js. Con Sequelize, puedes realizar una amplia variedad de operaciones en bases de datos de manera eficiente y fácilmente comprensible.

Por supuesto, profundicemos más en el uso de Sequelize para trabajar con tablas y realizar consultas comunes en bases de datos relacionales.

1. Definición de modelos:

En Sequelize, los modelos son representaciones de tablas en la base de datos. Cada modelo define la estructura de una tabla, incluyendo el nombre de la tabla, las columnas y sus tipos de datos. Además de los tipos de datos estándar como INTEGER, STRING y BOOLEAN, Sequelize también admite tipos de datos específicos del motor de base de datos que estés utilizando, como DATE, TEXT, JSON, etc.

Veamos un ejemplo más detallado de cómo definir un modelo en Sequelize:

javascript
const Usuario = sequelize.define('Usuario', {
  id: {
    type: Sequelize.INTEGER,
    primaryKey: true,
    autoIncrement: true
  },
  nombre: {
    type: Sequelize.STRING,
    allowNull: false // No permite valores nulos
  },
  correo: {
    type: Sequelize.STRING,
    unique: true // Asegura que los valores sean únicos
  },
  edad: Sequelize.INTEGER
});

En este ejemplo, hemos definido un modelo llamado Usuario con cuatro columnas: id, nombre, correo y edad. La columna id se establece como la clave primaria y se autoincrementa automáticamente. La columna nombre es obligatoria y no puede tener valores nulos, mientras que la columna correo debe ser única. La columna edad es opcional y puede tener valores nulos.

2. Relaciones entre modelos:

Una de las características poderosas de Sequelize es su capacidad para manejar relaciones entre tablas mediante asociaciones. Las asociaciones permiten establecer relaciones como uno a uno, uno a muchos y muchos a muchos entre diferentes modelos.

Por ejemplo, supongamos que tenemos un modelo adicional llamado Rol que representa los roles de los usuarios. Podemos definir una asociación uno a muchos entre los modelos Usuario y Rol, donde un usuario puede tener varios roles y cada rol puede ser asignado a varios usuarios. La definición de esta asociación se vería así:

javascript
const Rol = sequelize.define('Rol', {
  id: {
    type: Sequelize.INTEGER,
    primaryKey: true,
    autoIncrement: true
  },
  nombre: Sequelize.STRING
});

Usuario.hasMany(Rol, { as: 'Roles' });

Con esta asociación, Sequelize creará automáticamente una columna adicional en la tabla Rol llamada UsuarioId, que servirá como clave externa para establecer la relación entre las tablas Usuario y Rol.

3. Consultas avanzadas:

Además de las consultas básicas que hemos visto anteriormente, Sequelize también proporciona una amplia gama de métodos para realizar consultas más complejas, incluyendo consultas condicionales, agrupaciones, ordenamientos, limitaciones y más.

Por ejemplo, para realizar una consulta que devuelva todos los usuarios ordenados por edad de forma descendente y limitados a los primeros 10 resultados, podemos hacer lo siguiente:

javascript
Usuario.findAll({
  order: [['edad', 'DESC']],
  limit: 10
}).then(usuarios => {
  usuarios.forEach(usuario => {
    console.log(usuario.toJSON());
  });
}).catch(error => {
  console.error('Error al consultar usuarios:', error);
});

Esta consulta utilizará el método findAll para recuperar los primeros 10 usuarios ordenados por edad de forma descendente.

4. Migraciones y sincronización de modelos:

En entornos de desarrollo y producción, es importante mantener la consistencia entre los modelos y la estructura de la base de datos. Sequelize facilita esto mediante el uso de migraciones y sincronización de modelos.

Las migraciones permiten definir y aplicar cambios en la estructura de la base de datos de manera controlada, mientras que la sincronización de modelos actualiza automáticamente la estructura de la base de datos para que coincida con la definición de los modelos en tu aplicación.

Para crear y aplicar migraciones en Sequelize, puedes utilizar la CLI de Sequelize o escribir las migraciones manualmente utilizando JavaScript. Por ejemplo, para crear una migración que agregue una nueva columna a la tabla Usuario, puedes ejecutar el siguiente comando:

lua
sequelize migration:create --name agregar-columna-a-usuario

Esto creará un nuevo archivo de migración en el directorio de migraciones de tu proyecto, donde puedes definir las operaciones que deseas realizar en la base de datos.

En resumen, Sequelize es una poderosa herramienta para trabajar con bases de datos relacionales en Node.js. Desde la definición de modelos hasta la realización de consultas avanzadas y el mantenimiento de la estructura de la base de datos, Sequelize proporciona una amplia gama de funcionalidades que hacen que el desarrollo de aplicaciones basadas en bases de datos sea más eficiente y fácil de mantener.

Last Updated: 02/01/2025
7 minutos de lectura
Botón volver arriba