Relaciones muchos a muchos

Como dice el profesor, creo que es muy recomendable llevar el curso de Fundamentos de Bases de Datos aquí en Platzi. Es un curso lago pero muy completo para entender todas las opciones y configuraciones en bases de datos, tanto relacionales, como todos los demás tipos que hay.

No te rindas!!! Ya queda muy poco. Es un curso duro pero piensa en todo lo que has aprendido 🧠.
.
order-product.model.js
.

const { Model, DataTypes, Sequelize } = require('sequelize');

const { ORDER_TABLE } = require('./order.model');
const { PRODUCT_TABLE } = require('./product.model');

const ORDER_PRODUCT_TABLE = 'orders_products';

const OrderProductSchema =  {
  id: {
    allowNull: false,
    autoIncrement: true,
    primaryKey: true,
    type: DataTypes.INTEGER
  },
  createdAt: {
    allowNull: false,
    type: DataTypes.DATE,
    field: 'created_at',
    defaultValue: Sequelize.NOW,
  },
  amount: {
    allowNull: false,
    type: DataTypes.INTEGER
  },
  orderId: {
    field: 'order_id',
    allowNull: false,
    type: DataTypes.INTEGER,
    references: {
      model: ORDER_TABLE,
      key: 'id'
    },
    onUpdate: 'CASCADE',
    onDelete: 'SET NULL'
  },
  productId: {
    field: 'product_id',
    allowNull: false,
    type: DataTypes.INTEGER,
    references: {
      model: PRODUCT_TABLE,
      key: 'id'
    },
    onUpdate: 'CASCADE',
    onDelete: 'SET NULL'
  }
}

class OrderProduct extends Model {

  static associate(models) {
    //
  }

  static config(sequelize) {
    return {
      sequelize,
      tableName: ORDER_PRODUCT_TABLE,
      modelName: 'OrderProduct',
      timestamps: false
    }
  }
}

module.exports = { OrderProduct, OrderProductSchema, ORDER_PRODUCT_TABLE };

Cree un diagrama para entender mejor los modelos y sus relaciones. Aquí se los comparto:

En los modelos ORM se ocupan tablas ternarias para resolver las relaciones N-N (muchos a muchos). En los casos en lo cuales no se usa un ORM no necesariamente se ocupa una tabla ternaria, se puede resolver la relación con la sentencias JOIN, INNER JOIN, LEFT JOIN, RIGHT JOIN, etc. Esos temas se ven en cursos de bases de datos relacionales.

Aquí vuelvo a retomar esta clase después de 1 semana haciendo el curso de Fundamentos de Bases de Datos porque no entendía nada de lo que se estaba haciendo ya que son avanzados los tencnicísmos que el profesor explica y aplica para realizar este curso, y puedo decir que entiendo mucho mejor todo lo que hace inclusibe el orden de las carpetas y los archivos, si alguien está perdido como yo al principio le recomiendo pausar este curso y ir a hacer el curso de fundamentos de bases de datos de Platzi, que aunque es un curso largo se hace muy divertido y el profesor explica muy muy bien.

Espero que mi experiencia sirva de ayuda alguien, un saludo!

No he podido correr la migracion con el modelo order-product, siempre me da el siguiente error:

Repositorio

Las relaciones muchos a muchos se solucionan con la tabla ternaria, en este caso se crea la tabla order-product.

order-product.model.js:

const { Model, DataTypes, Sequelize } = require('sequelize');
const { ORDER_TABLE } = require('./order.model');
const { PRODUCT_TABLE } = require('./product.model');

const ORDER_PRODUCT_TABLE = 'orders_products'; // nombre de la tabla

const OrderProductSchema = {
  // El esquema define la estructura de la BD.
  id: {
    allowNull: false,
    autoIncrement: true,
    primaryKey: true,
    type: DataTypes.INTEGER,
  },
  createdAt: {
    allowNull: false,
    type: DataTypes.DATE,
    field: 'created_at',
    defaultValue: Sequelize.NOW,
  },
  amount: {
    type: DataTypes.INTEGER,
    allowNull: false,
  },
  orderId: {
    field: 'order_id',
    allowNull: false,
    type: DataTypes.INTEGER,
    references: {
      model: ORDER_TABLE,
      key: 'id',
    },
  },
  productId: {
    field: 'product_id',
    allowNull: false,
    type: DataTypes.INTEGER,
    references: {
      model: PRODUCT_TABLE,
      key: 'id',
    },
    onUpdate: 'CASCADE',
    onDelete: 'SET NULL',
  },
};

class OrderProduct extends Model {
  static associate(models) {}

  static config(sequelize) {
    return {
      sequelize,
      tableName: ORDER_PRODUCT_TABLE,
      modelName: 'OrderProduct',
      timestamps: false,
    };
  }
}

module.exports = { ORDER_PRODUCT_TABLE, OrderProductSchema, OrderProduct };

Se configura el init de la nueva tabla y se corren las migraciones correspondientes.

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');
const { Order, OrderSchema } = require('./order.model');
const { OrderProduct, OrderProductSchema } = require('./order-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));
  Order.init(OrderSchema, Order.config(sequelize));
  OrderProduct.init(OrderProductSchema, OrderProduct.config(sequelize));

  User.associate(sequelize.models);
  Customer.associate(sequelize.models);
  Category.associate(sequelize.models);
  Product.associate(sequelize.models);
  Order.associate(sequelize.models);
}

module.exports = setupModels;

Si se desea que Order resuelva los items (productos enlazados a esa orden) a través de OrderProduct, se puede hacer la relación en el modelo de Order.

Esto se hace de la siguiente forma en order.model.js:

static associate(models) {
    this.belongsTo(models.Customer, {
      as: 'customer',
    });
    this.belongsToMany(models.Product, {
      as: 'items',
      through: models.OrderProduct,
      foreignKey: 'orderId',
      otherKey: 'productId',
    });
  }

Se hace el uso de belongsToMany para decirle cuál es ese item que va a tener muchos productos. Como es una relación muchos a muchos se debe especificar cuál es la tabla ternaria, es decir, qué tabla va a resolver esa relación y se hace a través de la propiedad through especificando las llaves foráneas de ambas tablas usando las propiedades foreignKey y otherKey.

Super, ya quedo mi order-products