Establish a many-to-many relationship when a single instance of Entity A can be associated with multiple instances of Entity B and vice versa. In a musical platform built with Nest.js, consider that many artists can publish many songs, and similarly, a single song can belong to multiple artists. This relationship exemplifies the concept of high cardinality in database design, ensuring that your data structure can capture complex associations without redundancy.

@Entity("artists")
export class Artist {
  @OneToOne(() => User)
  @JoinColumn()
  user: User;

  @ManyToMany(() => Song, (song) => song.artists)
  songs: Song[];
}

 relation in the Artist entity. The first argument specifies the target entity, and the second argument represents the inverse side of the relationship.

@Entity("songs")
export class Song {
  // @Column('varchar', { array: true })
  // artists: string[];

  @ManyToMany(() => Artist, (artist) => artist.songs, { cascade: true })
  @JoinTable({ name: "songs_artists" })
  artists: Artist[];
}

Refactor the Artist's column; storing it as an array of strings is unnecessary. Instead, use the 

 annotation to define a relationship with another entity, specifying the target entity as the first argument and the inverse side as the second argument, found in the 

cascade: boolean | ("insert" | "update")[]

 parameter. Setting it to true will automatically manage the related object's insertion and updates. Specific cascade options can also be set as an array.

 relationships. Optionally, rename the JoinTable to create a table named 

 in the database. This table will house the primary keys from both the 

 annotations are typical of TypeORM, which Nest.js leverages for database operations. The cascade option is an example of the software engineering principle of DRY (Don't Repeat Yourself), as it automates CRUD operations for related entities. Meanwhile, the joined table is a clear manifestation of the database normalization principle, optimizing the data structure.

---
title: Many to Many Relation
privateVideoUrl: https://fullstack.wistia.com/medias/u2sv3gszyx
isPublicLesson: true
---

## Many to Many Relation

Establish a many-to-many relationship when a single instance of Entity A can be associated with multiple instances of Entity B and vice versa. In a musical platform built with Nest.js, consider that many artists can publish many songs, and similarly, a single song can belong to multiple artists. This relationship exemplifies the concept of high cardinality in database design, ensuring that your data structure can capture complex associations without redundancy.

## Add Many to Many Relation in Artist

```ts
@Entity("artists")
export class Artist {
  @OneToOne(() => User)
  @JoinColumn()
  user: User;

  @ManyToMany(() => Song, (song) => song.artists)
  songs: Song[];
}
```

Add the `@ManyToMany` relation in the Artist entity. The first argument specifies the target entity, and the second argument represents the inverse side of the relationship.

## Add Many to Many Relation in Song

```ts
@Entity("songs")
export class Song {
  // @Column('varchar', { array: true })
  // artists: string[];

  @ManyToMany(() => Artist, (artist) => artist.songs, { cascade: true })
  @JoinTable({ name: "songs_artists" })
  artists: Artist[];
}
```

Refactor the Artist's column; storing it as an array of strings is unnecessary. Instead, use the `@ManyToMany` annotation to define a relationship with another entity, specifying the target entity as the first argument and the inverse side as the second argument, found in the `songs` property within the `Artist` entity.

For cascading actions, use the `cascade: boolean | ("insert" | "update")[]` parameter. Setting it to true will automatically manage the related object's insertion and updates. Specific cascade options can also be set as an array.

Include the `@JoinTable()` annotation, which is mandatory for `@ManyToMany` relationships. Optionally, rename the JoinTable to create a table named `songs_artists` in the database. This table will house the primary keys from both the `songs` and `artists` tables, functioning as foreign keys.

Here, the `@ManyToMany` and `@JoinTable()` annotations are typical of TypeORM, which Nest.js leverages for database operations. The cascade option is an example of the software engineering principle of DRY (Don't Repeat Yourself), as it automates CRUD operations for related entities. Meanwhile, the joined table is a clear manifestation of the database normalization principle, optimizing the data structure.

Haider Malik

Many to Many Relation

Now we cannot talk about how to implement many to many relationships.

Many to many relationships is a relation where A contains multiple instances of

And B entity contains multiple instances of A.

Let's take an example many artists can publish many songs and multiple artists

to one song or multiple artists can publish multiple songs.

We have a multiple many to many relationship.

Inside the artist NestJS or type ORM provides many to many decorators.

This will specify the target relation entity and this is the inverse side of

It will have the songs array and on this song we will have the artist array.

We have a many to many decorators the target entity in the song we have target

is artist and the second argument specify the inverse side of the relationship

the artist we have songs property that's why I can access the artist or songs

the artist entity we have song.artis that's why I can access the artist from

entity song.artis that is the inverse side of the relation when you send the

to true it means you can create or update the record while creating a new song

artist I will teach you the benefits of cascading when you implement the many

you need a joint table many to many relationship always work with third table

joint table and I rename it to songs artist and this songs artist will have

of the song and the primary key of the artist as a foreign key.

And we also need to re-effect some create song DTO instead of using a string we

to get IDs from the request parameter IDs of the artist and IDs of the artist

update song DTO and then you have to register the artist entity in the songs

because I want to access the artist repository inside the songs module and

to re-effect the create method we're going to get artist here the first step we

to get these artist IDs from the request object request parameter for the

then we will find all the artist on the based on IDs and finally here we are

the song dot artist equals to artist if you have set the cascade to true just

have done it done it here cascading we set to true now it will set the

songs and the artist it will automatically create the record with third table

the join table here it will create a record it creates records in the songs

by setting the relation with this one song start song note artist should be

finally we are going to save the song in the using song repository and you can

application level let's implement it first.

So we have many to many relationship I'm going to add this relationship inside

artist I'm going to do it here this specify the target relation type.

And we don't have we did not get the song dot artist inside the song entity now

the songs array let's import many to many I'm also going to implement it here

many decorator the target entity in our case it's an artist and it's going to

artist let's specify the inverse side of the relation artist dot songs and we

join table I'm going to name it to songs artist or artist song let's take it

and finally I'm going to specify the artist array.

duplicate identify yeah I don't need this type because I'm not getting the

from the artist instead of I'm getting the array of the artist from the request

we added many to many relationship inside the song model or song entity and we

to set the task heading to true here you can do it inside here

ask it to true now we need to refactor the creates on ddo

I have to refactor it from it should be number and the first argument is an

good similarly we have to refactor the update song dto it should be number

the first argument is empty looks good now we need to register the artist

the songs module so we can access the artist repository inside the song service

to type or I would like to access the artist repository inside the songs module

song service that's why I have to register it here and finally we need to ref

song inside the song service so you can do it too if you want here we have to

the artists on the based on ID then we have to set the relation with artist and

so you can do it but first of all we have to inject the repository which is

can say private artist repository and repository I can say artist

let's get all the artist you have to add a sync here this dot song artist

Learn

The newline Guide to Building Your First GraphQL Server with Node and TypeScript

Teach

Amelia Wattenberger

Author of Fullstack D3

Community

Masterclasses

Tutorials

Fullstack React with TypeScript