Por lo general para resolver una relación de muchos a muchos (n:n) se suele crear una tabla intermedia, también conocida como entidad asociativa, que tenga una referencia a las llaves primarias de ambas tablas y rompa dicha relación para que se pueda manejar mucho más fácilmente. Sequelize usa el mismo proceso para resolver estas relaciones a través del método belongsToMany, con este le indicamos cómo se llamará la tabla intermedia y cómo funciona la relación entre los dos modelos.

Veamos cómo podríamos resolver una relación de muchos a muchos usando los modelos Student y Course, donde un estudiante puede tomar varios cursos, así como un curso puede tener a varios estudiantes inscritos. El primer paso para resolver el problema es crear los schemas correspondientes a cada modelo.

**const { DataTypes, Sequelize } = require("sequelize");

const sequelize = new Sequelize("your URI string", {...options});
const studentSchema = {
	id: {
		type: DataTypes.INTEGER,
		allowNull: false,
		unique: true,
		autoIncrement: true,
		primaryKey: true,
	},
	name: {
		type: DataTypes.STRING,
		allowNull: false,
	}
};
const courseSchema = {
	id: {
		type: DataTypes.INTEGER,
		allowNull: false,
		unique: true,
		autoIncrement: true,
		primaryKey: true,
	},
	name: {
		type: DataTypes.STRING,
		allowNull: false,
	}
};**

Después de tener nuestros schemas listos podemos utilizarlos para definir los modelos que necesitamos.

**const Student = sequelize.define("Student", studentSchema, {
	tableName: "students",
	timestamps: false
});
const Course = sequelize.define("Course", courseSchema, {
	tableName: "courses",
	timestamps: false
});**

Ya tenemos nuestros dos modelos, ahora necesitamos crear esa tabla intermedia que nos permita romper la relación de muchos a muchos, para este caso usaremos la tabla enrollment (inscripción).

**const enrollmentSchema = {
	id: {
		type: DataTypes.INTEGER,
		primaryKey: true,
		unique: true,
		autoIncrement: true,
		allowNull: false,
	},
	studentId: {
		field: "student_id",
		allowNull: false,
		type: DataTypes.INTEGER,
		references: {
			model: "students",
			key: "id"
		},
		onUpdate: "CASCADE",
		onDelete: "SET NULL",
	},
	courseId: {
		field: "course_id",
		allowNull: false,
		type: DataTypes.INTEGER,
		references: {
			model: "courses",
			key: "id"
		},
		onUpdate: "CASCADE",
		onDelete: "SET NULL",
	}
};

const Enrollment = sequelize.define("Enrollment", enrollmentSchema, {
	tableName: "enrollments",
	timestamps: false,
});
sequelize.sync(); //también se podrían usar migraciones.**

Como se puede ver en el schema del modelo que definimos para la tabla intermedia (Enrollment), creamos dos llaves foráneas, una que apunta hacia el campo id de la tabla students y la otra que apunta hacia el campo id de la tabla courses.

La tabla intermedia también termina siendo un modelo.

Con esto ya tenemos todas las tablas y modelos listas, solo falta utilizar el método belongsToMany para decirle a Sequelize que haga efectiva la relación.

**Course.belongsToMany(Student, {
	through: Enrollment,
	foreignKey: "courseId",
	otherKey: "studentId",
	as: "students",
});**

En el objeto de configuración que recibe el método belongsToMany indicamos que queremos romper la relación muchos a muchos a través del modelo Enrollment, además con las propiedades **foreignKey**y otherKey le indicamos cuáles campos que hacen de llave foránea dentro de dicho modelo. Finalmente con la propiedad as le asignamos un alias a esta relación que nos permita hacer peticiones complejas en el futuro.

Student.belongsToMany(Course, {...options}); también funciona.

Y con esto hecho ya resolvimos nuestra relación de muchos a muchos usando Sequelize.