El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Usando Bases de Datos SQL con Sequelize

Siguiente ►
►

Introducción

Sequelize es un ORM (Object-Relational Mapping) para Node.js que facilita la interacción con bases de datos SQL como MySQL, PostgreSQL, SQLite y MSSQL. Sequelize permite definir modelos que representan tablas en la base de datos y proporciona métodos para realizar operaciones CRUD (Crear, Leer, Actualizar, Eliminar) de manera sencilla.

Contenido

  1. Instalación de Sequelize
  2. Configuración de Sequelize
  3. Definición de Modelos
  4. Operaciones CRUD
  5. Relaciones entre Modelos
  6. Ejercicios Prácticos

Instalación de Sequelize

Para comenzar a usar Sequelize, primero necesitamos instalar Sequelize y el paquete del cliente de la base de datos que vamos a utilizar. En este ejemplo, usaremos PostgreSQL.

npm install sequelize pg pg-hstore

Configuración de Sequelize

Después de instalar Sequelize, necesitamos configurarlo para conectarnos a nuestra base de datos. Creamos un archivo config/database.js para manejar la configuración.

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

// Configuración de la conexión a la base de datos
const sequelize = new Sequelize('database_name', 'username', 'password', {
  host: 'localhost',
  dialect: 'postgres', // Puede ser 'mysql', 'sqlite', 'mssql', etc.
});

module.exports = sequelize;

Definición de Modelos

Los modelos en Sequelize representan tablas en la base de datos. Vamos a definir un modelo User como ejemplo.

const { DataTypes } = require('sequelize');
const sequelize = require('./config/database');

// Definición del modelo User
const User = sequelize.define('User', {
  // Definición de atributos
  firstName: {
    type: DataTypes.STRING,
    allowNull: false,
  },
  lastName: {
    type: DataTypes.STRING,
    allowNull: false,
  },
  email: {
    type: DataTypes.STRING,
    allowNull: false,
    unique: true,
  },
}, {
  // Opciones del modelo
  timestamps: true,
});

module.exports = User;

Operaciones CRUD

Crear

Para crear un nuevo registro en la tabla User, usamos el método create.

const User = require('./models/User');

async function createUser() {
  try {
    const user = await User.create({
      firstName: 'John',
      lastName: 'Doe',
      email: '[email protected]',
    });
    console.log('User created:', user.toJSON());
  } catch (error) {
    console.error('Error creating user:', error);
  }
}

createUser();

Leer

Para leer registros de la tabla User, usamos el método findAll o findOne.

async function getUsers() {
  try {
    const users = await User.findAll();
    console.log('All users:', JSON.stringify(users, null, 2));
  } catch (error) {
    console.error('Error fetching users:', error);
  }
}

getUsers();

Actualizar

Para actualizar un registro, usamos el método update.

async function updateUser(id) {
  try {
    const result = await User.update({ lastName: 'Smith' }, {
      where: { id: id }
    });
    console.log('Number of affected rows:', result[0]);
  } catch (error) {
    console.error('Error updating user:', error);
  }
}

updateUser(1);

Eliminar

Para eliminar un registro, usamos el método destroy.

async function deleteUser(id) {
  try {
    const result = await User.destroy({
      where: { id: id }
    });
    console.log('Number of deleted rows:', result);
  } catch (error) {
    console.error('Error deleting user:', error);
  }
}

deleteUser(1);

Relaciones entre Modelos

Sequelize permite definir relaciones entre modelos, como uno a muchos, muchos a muchos, etc. Vamos a definir una relación uno a muchos entre User y Post.

const Post = sequelize.define('Post', {
  title: {
    type: DataTypes.STRING,
    allowNull: false,
  },
  content: {
    type: DataTypes.TEXT,
    allowNull: false,
  },
});

// Definición de la relación
User.hasMany(Post, { foreignKey: 'userId' });
Post.belongsTo(User, { foreignKey: 'userId' });

module.exports = { User, Post };

Ejercicios Prácticos

Ejercicio 1: Crear y Leer Usuarios

  1. Crea un nuevo usuario con los datos firstName: 'Alice', lastName: 'Johnson', email: '[email protected]'.
  2. Lee todos los usuarios y muestra los resultados en la consola.

Ejercicio 2: Actualizar y Eliminar Usuarios

  1. Actualiza el lastName del usuario con email: '[email protected]' a Williams.
  2. Elimina el usuario con email: '[email protected]'.

Ejercicio 3: Relaciones entre Modelos

  1. Crea un nuevo Post para un usuario existente.
  2. Lee todos los Post de un usuario específico y muestra los resultados en la consola.

Soluciones

Solución Ejercicio 1

async function exercise1() {
  try {
    // Crear usuario
    const user = await User.create({
      firstName: 'Alice',
      lastName: 'Johnson',
      email: '[email protected]',
    });
    console.log('User created:', user.toJSON());

    // Leer usuarios
    const users = await User.findAll();
    console.log('All users:', JSON.stringify(users, null, 2));
  } catch (error) {
    console.error('Error in exercise 1:', error);
  }
}

exercise1();

Solución Ejercicio 2

async function exercise2() {
  try {
    // Actualizar usuario
    const result = await User.update({ lastName: 'Williams' }, {
      where: { email: '[email protected]' }
    });
    console.log('Number of affected rows:', result[0]);

    // Eliminar usuario
    const deleteResult = await User.destroy({
      where: { email: '[email protected]' }
    });
    console.log('Number of deleted rows:', deleteResult);
  } catch (error) {
    console.error('Error in exercise 2:', error);
  }
}

exercise2();

Solución Ejercicio 3

async function exercise3() {
  try {
    // Crear post
    const user = await User.findOne({ where: { email: '[email protected]' } });
    const post = await Post.create({
      title: 'My First Post',
      content: 'This is the content of my first post.',
      userId: user.id,
    });
    console.log('Post created:', post.toJSON());

    // Leer posts de un usuario
    const posts = await Post.findAll({ where: { userId: user.id } });
    console.log('All posts for user:', JSON.stringify(posts, null, 2));
  } catch (error) {
    console.error('Error in exercise 3:', error);
  }
}

exercise3();

Conclusión

En esta sección, hemos aprendido a usar Sequelize para interactuar con bases de datos SQL en Node.js. Hemos cubierto la instalación y configuración de Sequelize, la definición de modelos, y cómo realizar operaciones CRUD. También hemos explorado cómo definir relaciones entre modelos y hemos practicado con ejercicios prácticos. Con estos conocimientos, estás preparado para manejar bases de datos SQL en tus aplicaciones Node.js de manera eficiente.

◄ Anterior
◄
Siguiente ►
►

Curso de Node.js

Módulo 1: Introducción a Node.js

Módulo 2: Conceptos Básicos

Módulo 3: Sistema de Archivos y E/S

Módulo 4: HTTP y Servidores Web

Módulo 5: NPM y Gestión de Paquetes

Módulo 6: Framework Express.js

Módulo 7: Bases de Datos y ORMs

Módulo 8: Autenticación y Autorización

Módulo 9: Pruebas y Depuración

Módulo 10: Temas Avanzados

Módulo 11: Despliegue y DevOps

Módulo 12: Proyectos del Mundo Real

El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados