Si tienen algún problema al hacer la migración pueden usar el comando:
sequelize-cli db:migrate --debug
Para hallar más información sobre el error.
¿Cómo se implementan relaciones uno a muchos en bases de datos relacionales?
Cuando trabajamos con bases de datos relacionales, las relaciones uno a muchos son fundamentales y comúnmente utilizadas para estructurar datos de manera eficiente. En el contexto de un sistema de categorías y productos, este tipo de relación es esencial para asociar múltiples productos a una única categoría. Aunque puede sonar complejo, SQLite ofrece métodos claros y eficientes para gestionar estas relaciones. Vamos a explorar cómo puedes implementarlo.
¿Qué pasos se siguen para configurar la estructura de una categoría?
Para empezar, debemos tener en cuenta que una categoría puede contener varios productos, mientras que un producto solo puede pertenecer a una categoría. La relación se establece utilizando HasMany, donde se define que la relación es manejada por la entidad más débil, en este caso, los productos.
Modelo de categoría: Definimos un modelo básico para las categorías. Los atributos principales incluyen:
ID: es la clave primaria.Nombre: debe ser único, asegurando que no haya dos categorías con el mismo nombre.Imagen: un campo adicional para ilustrar la categoría.Fecha de creación: para llevar un seguimiento temporal.Esquema de categoría: Creamos y exportamos el esquema que define estos atributos, asegurando que el modelo sea flexible para futuras expansiones o migraciones.
¿Cómo se definen los atributos del producto?
El modelo de productos, sin duda, es un poco más extenso debido a la variedad de atributos que podría albergar un producto. Aquí está cómo se estructuran:
Campos principales:
ID: como la clave primaria, similar a la categoría.Nombre: que en productos puede repetirse, a diferencia de las categorías.Imagen: para presentar visualmente al producto.Descripción: un campo de texto necesario y no nulo, permitiendo explicaciones detalladas.Precio: de tipo entero y no nulo.Relación con categoría: Se añade un Category ID como campo de clave externa, referenciando la tabla de categorías. Esto asegura que cada producto pueda fácilmente estar vinculado a su respectiva categoría a través de un valor de clave compartida.
¿Cómo se crean las asociaciones entre categorías y productos?
La clave para manejar relaciones uno a muchos es definir claramente cómo cada producto se asocia a una categoría, y viceversa. Aquí te muestro cómo se implementa:
hasMany, determinamos esta relación, especificando que la foreign key será Category ID.category.hasMany(models.product, { foreignKey: 'categoryId', as: 'products' });
belongsTo.product.belongsTo(models.category, { foreignKey: 'categoryId', as: 'category' });
¿Qué se debe considerar para manejar migraciones al crear una base de datos nueva?
Crear una estructura de base de datos clara y funcional es crucial. Una vez definidas las relaciones y los modelos, generamos una migración que contiene las reglas y estructuras necesarias para las tablas:
Al ejecutar la migración, obtendremos las estructuras de base de datos alineadas con las especificaciones de nuestros modelos.
Implementando estas relaciones y configuraciones adecuadamente, el sistema puede manejar eficientemente los interacciones y la administración de productos dentro de sus categorías correspondientes, lo que resulta fundamental en una tienda virtual bien estructurada. Ahora, continúa perfeccionando tus habilidades y prepárate para abordar los endpoints y lógicas de servicio en tu siguiente paso de aprendizaje. ¡Sigue adelante!
Cuando trabajamos con bases de datos relacionales, las relaciones uno a muchos son fundamentales y comúnmente utilizadas para estructurar datos de manera eficiente. En el contexto de un sistema de categorías y productos, este tipo de relación es esencial para asociar múltiples productos a una única categoría. Aunque puede sonar complejo, SQLite ofrece métodos claros y eficientes para gestionar estas relaciones. Vamos a explorar cómo puedes implementarlo.
Para empezar, debemos tener en cuenta que una categoría puede contener varios productos, mientras que un producto solo puede pertenecer a una categoría. La relación se establece utilizando HasMany, donde se define que la relación es manejada por la entidad más débil, en este caso, los productos.
Modelo de categoría: Definimos un modelo básico para las categorías. Los atributos principales incluyen:
ID: es la clave primaria.Nombre: debe ser único, asegurando que no haya dos categorías con el mismo nombre.Imagen: un campo adicional para ilustrar la categoría.Fecha de creación: para llevar un seguimiento temporal.Esquema de categoría: Creamos y exportamos el esquema que define estos atributos, asegurando que el modelo sea flexible para futuras expansiones o migraciones.
El modelo de productos, sin duda, es un poco más extenso debido a la variedad de atributos que podría albergar un producto. Aquí está cómo se estructuran:
Campos principales:
ID: como la clave primaria, similar a la categoría.Nombre: que en productos puede repetirse, a diferencia de las categorías.Imagen: para presentar visualmente al producto.Descripción: un campo de texto necesario y no nulo, permitiendo explicaciones detalladas.Precio: de tipo entero y no nulo.Relación con categoría: Se añade un Category ID como campo de clave externa, referenciando la tabla de categorías. Esto asegura que cada producto pueda fácilmente estar vinculado a su respectiva categoría a través de un valor de clave compartida.
La clave para manejar relaciones uno a muchos es definir claramente cómo cada producto se asocia a una categoría, y viceversa. Aquí te muestro cómo se implementa:
hasMany, determinamos esta relación, especificando que la foreign key será Category ID.category.hasMany(models.product, {
foreignKey: 'categoryId',
as: 'products'
});
belongsTo.product.belongsTo(models.category, {
foreignKey: 'categoryId',
as: 'category'
});
Crear una estructura de base de datos clara y funcional es crucial. Una vez definidas las relaciones y los modelos, generamos una migración que contiene las reglas y estructuras necesarias para las tablas:
Al ejecutar la migración, obtendremos las estructuras de base de datos alineadas con las especificaciones de nuestros modelos.
Implementando estas relaciones y configuraciones adecuadamente, el sistema puede manejar eficientemente los interacciones y la administración de productos dentro de sus categorías correspondientes, lo que resulta fundamental en una tienda virtual bien estructurada. Ahora, continúa perfeccionando tus habilidades y prepárate para abordar los endpoints y lógicas de servicio en tu siguiente paso de aprendizaje. ¡Sigue adelante!
Si tienen algún problema al hacer la migración pueden usar el comando:
sequelize-cli db:migrate --debug
Para hallar más información sobre el error.
Al crear estas 2 tablas(en el .js de la migracion), hay que hacerlas en la misma posición que la clase. Sino les va a dar error ya que Sequelize va a intentar crear primero productos pero al no existir la tabla de category no va a tener forma de hacer la relación
En este caso, cuando se utiliza hasMany, la relación queda en productos. La relación va en la entidad débil (productos).
De la misma manera que se hizo en la relación uno a uno, se hacen las asociaciones correspondientes en los modelos, se genera la migración, se configura el init y se corre la migración.
product.model.js:
const { Model, DataTypes, Sequelize } = require('sequelize');
const { CATEGORY_TABLE } = require('./category.model');
const PRODUCT_TABLE = 'products'; // nombre de la tabla
const ProductSchema = {
// El esquema define la estructura de la BD.
id: {
allowNull: false,
autoIncrement: true,
primaryKey: true,
type: DataTypes.INTEGER,
},
name: {
allowNull: false,
type: DataTypes.STRING,
},
image: {
allowNull: false,
type: DataTypes.STRING,
},
description: {
allowNull: false,
type: DataTypes.TEXT,
},
price: {
allowNull: false,
type: DataTypes.INTEGER,
},
createdAt: {
allowNull: false,
type: DataTypes.DATE,
field: 'created_at',
defaultValue: Sequelize.NOW,
},
categoryId: {
field: 'category_id',
allowNull: false,
type: DataTypes.INTEGER,
references: {
model: CATEGORY_TABLE,
key: 'id',
},
onUpdate: 'CASCADE',
onDelete: 'SET NULL',
},
};
class Product extends Model {
static associate(models) {
this.belongsTo(models.Category, { as: 'category' });
}
static config(sequelize) {
return {
sequelize,
tableName: PRODUCT_TABLE,
modelName: 'Product',
timestamps: false,
};
}
}
module.exports = { Product, PRODUCT_TABLE, ProductSchema };
category.model.js:
const { Model, DataTypes, Sequelize } = require('sequelize');
const CATEGORY_TABLE = 'categories'; // nombre de la tabla
const CategorySchema = {
// El esquema define la estructura de la BD.
id: {
allowNull: false,
autoIncrement: true,
primaryKey: true,
type: DataTypes.INTEGER,
},
name: {
allowNull: false,
type: DataTypes.STRING,
unique: true,
},
image: {
allowNull: false,
type: DataTypes.STRING,
},
createdAt: {
allowNull: false,
type: DataTypes.DATE,
field: 'created_at',
defaultValue: Sequelize.NOW,
},
};
class Category extends Model {
static associate(models) {
this.hasMany(models.Product, {
as: 'products',
foreignKey: 'categoryId',
});
}
static config(sequelize) {
return {
sequelize,
tableName: CATEGORY_TABLE,
modelName: 'Category',
timestamps: false,
};
}
}
module.exports = { Category, CATEGORY_TABLE, CategorySchema };
Migración product:
'use strict';
const { CategorySchema, CATEGORY_TABLE } = require('../models/category.model');
const { ProductSchema, PRODUCT_TABLE } = require('../models/product.model');
module.exports = {
up: async (queryInterface) => {
await queryInterface.createTable(CATEGORY_TABLE, CategorySchema);
await queryInterface.createTable(PRODUCT_TABLE, ProductSchema);
},
down: async (queryInterface) => {
await queryInterface.dropTable(CATEGORY_TABLE);
await queryInterface.dropTable(PRODUCT_TABLE);
},
};
db/models/index.js:
const { User, UserSchema } = require('./user.model');
const { Customer, CustomerSchema } = require('./customer.model');
const { Category, CategorySchema } = require('./category.model');
const { Product, ProductSchema } = require('./product.model');
function setupModels(sequelize) {
User.init(UserSchema, User.config(sequelize));
Customer.init(CustomerSchema, Customer.config(sequelize));
Category.init(CategorySchema, Category.config(sequelize));
Product.init(ProductSchema, Product.config(sequelize));
User.associate(sequelize.models);
Customer.associate(sequelize.models);
Category.associate(sequelize.models);
Product.associate(sequelize.models);
}
module.exports = setupModels;
Les dejo el código de Product y Category por si no quieren escribir :D .
category.model.js
const { Model, DataTypes, Sequelize } = require('sequelize');
const CATEGORY_TABLE = 'categories';
const CategorySchema = {
id: {
allowNull: false,
autoIncrement: true,
primaryKey: true,
type: DataTypes.INTEGER,
},
name: {
type: DataTypes.STRING,
unique: true,
allowNull: false,
},
image: {
type: DataTypes.STRING,
allowNull: false,
},
createdAt: {
allowNull: false,
type: DataTypes.DATE,
field: 'created_at',
defaultValue: Sequelize.NOW,
},
};
class Category extends Model {
static associate(models) {
this.hasMany(models.Product, {
as: 'products',
foreignKey: 'categoryId',
});
}
static config(sequelize) {
return {
sequelize,
tableName: CATEGORY_TABLE,
modelName: 'Category',
timestamps: false,
};
}
}
module.exports = { Category, CategorySchema, CATEGORY_TABLE };
. product.model.js .
const { Model, DataTypes, Sequelize } = require('sequelize');
const { CATEGORY_TABLE } = require('./category.model');
const PRODUCT_TABLE = 'products';
const ProductSchema = {
id: {
allowNull: false,
autoIncrement: true,
primaryKey: true,
type: DataTypes.INTEGER,
},
name: {
type: DataTypes.STRING,
allowNull: false,
},
image: {
type: DataTypes.STRING,
allowNull: false,
},
description: {
type: DataTypes.TEXT,
allowNull: false,
},
price: {
type: DataTypes.INTEGER,
allowNull: false,
},
createdAt: {
allowNull: false,
type: DataTypes.DATE,
field: 'created_at',
defaultValue: Sequelize.NOW,
},
categoryId: {
field: 'category_id',
allowNull: false,
type: DataTypes.INTEGER,
references: {
model: CATEGORY_TABLE,
key: 'id',
},
onUpdate: 'CASCADE',
onDelete: 'SET NULL',
},
};
class Product extends Model {
static associate(models) {
this.belongsTo(models.Category, { as: 'category' });
}
static config(sequelize) {
return {
sequelize,
tableName: PRODUCT_TABLE,
modelName: 'Product',
timestamps: false,
};
}
}
module.exports = { Product, ProductSchema, PRODUCT_TABLE };
Increible, cada vez que avanzo en el curso y en la ruta de escuela de javascript me siento increiblemente preparado con todo lo que estoy aprendiendo, es realmente facinante este mundo del backend con node, con este curso definitivamente creo que el backend es lo mio :)
demasiada informacion en un solo curso.. pg, pgmyadmin, sql, phpmyadmin, docker, sequelice, relaciones, migraciones y mas...
La forma en la que estamos utilizando el schema para las migrations no es compatible con la idea de lo que son las migraciones en un ambiente compartido, porque si por ejemplo creo mi schema y en base a ese schema creo mis migrations, luego, actualizo el schema y en base a esa actualizacion creo una nueva migration y esos dos cambios los comiteo a git, quien se baje mis cambios por primera vez y corra la primer migration, ya va a tomar los cambios con el schema actualizado y va a romper al intentar ejecutar las migrations siguientes.
Se me ocurre como solucion, no usar el schema como import, sino que copiarlo en cada migration. Tambien para que quede un historico mas detallado de que se hizo en cada migration.
//FK
categoryId: {
field: 'category_id',
allowNull: false,
type: DataTypes.INTEGER,
references: {
model: CATEGORIES_TABLE,
key: 'id'
},
onUpdate: 'CASCADE',
onDelet: 'SET NULL'
}
class Product extends Model {
static associate(models) {
this.belongsTo(models.Category, { as: 'category' })
}
static config(sequelize) {
return {
sequelize,
tableName: PRODUCTS_TABLE,
modelName: 'Product',
timestamps: false
}
}
}
class Categorie extends Model {
static associate(models) {
this.hasMany(models.Product, {
as: 'products',
foreignKey: 'categoryId'
});
}
static config(sequelize) {
return {
sequelize,
tableName: CATEGORIES_TABLE,
modelName: 'Categorie',
timestamps: false
}
}
}
una ayuda please. he escrito todo el codigo igual que en la clase pero men sale este error:

HasMany en el modelo de la entidad principal (categoría) y BelongsTo en la entidad dependiente (producto).foreign key (categoryID), permitiendo múltiples registros asociados.Category y Product, asegurando la integridad de los datos con restricciones como unique o tipos de campo (text, integer).foreign key correspondiente para permitir consultas anidadas.