Relations (OneToMany, ManyToOne, ManyToMany) in NestJS - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does a OneToMany relation represent in NestJS with TypeORM?

It means one entity instance can be linked to many instances of another entity. For example, one author can have many books.

beginner

Explain the ManyToOne relation in NestJS.

Many instances of an entity relate to one instance of another entity. For example, many books belong to one author.

intermediate

How does a ManyToMany relation work in NestJS?

It connects many instances of one entity to many instances of another. For example, many students can enroll in many courses.

intermediate

In NestJS, which decorator is used to define the owner side of a ManyToOne relation?

The @ManyToOne decorator is used on the owner side, which holds the foreign key to the related entity.

intermediate

What is the purpose of the @JoinTable() decorator in a ManyToMany relation?

It marks the owner side of the ManyToMany relation and creates a join table to store the relation links.

Which decorator defines a one-to-many relation in NestJS with TypeORM?

A @OneToMany

B @ManyToOne

C @ManyToMany

D @JoinColumn

The @OneToMany decorator defines a one-to-many relation where one entity relates to many others.

In a ManyToOne relation, where is the foreign key stored?

A On the entity with the ManyToOne decorator

B On the entity with the OneToMany decorator

C In a separate join table

D No foreign key is used

The foreign key is stored on the entity that has the ManyToOne decorator, which is the owner side.

What does the @JoinTable() decorator do in a ManyToMany relation?

A Defines a foreign key column

B Creates a join table to link both entities

C Marks a column as primary key

D Specifies eager loading

@JoinTable() creates a join table that stores the links between the two entities in a ManyToMany relation.

Which relation type allows many instances of one entity to relate to many instances of another?

A ManyToOne

B OneToMany

C ManyToMany

D OneToOne

ManyToMany relations connect many instances of one entity to many instances of another.

If an Author has many Books, which decorator would you use on the Author entity?

A @ManyToMany

B @ManyToOne

C @JoinColumn

D @OneToMany

The Author entity uses @OneToMany to show it has many Books.

Describe how to set up a OneToMany and ManyToOne relation between two entities in NestJS.

Think about how one author can have many books and how each book belongs to one author.

Explain the role of @JoinTable in a ManyToMany relation and which side should have it.

Imagine a table that connects students and courses they attend.

Practice

1. In NestJS using TypeORM, which decorator correctly defines a OneToMany relationship from an Author entity to a Book entity?

easy

A. @OneToMany(() => Book, book => book.author)

B. @ManyToOne(() => Book, book => book.author)

C. @ManyToMany(() => Book, book => book.author)

D. @OneToOne(() => Book, book => book.author)

Solution

1. Step 1: Understand the relationship direction

   A OneToMany relationship means one Author has many Books.

2. Step 2: Identify the correct decorator syntax

   The decorator @OneToMany(() => Book, book => book.author) correctly sets this relation from Author to Book.

3. Final Answer:

   @OneToMany(() => Book, book => book.author) -> Option A

4. Quick Check:

   OneToMany from Author to Book = @OneToMany [OK]

Hint: OneToMany decorator links one entity to many others [OK]

Common Mistakes:

• Confusing OneToMany with ManyToOne
• Using ManyToMany instead of OneToMany
• Incorrect arrow function syntax in decorator

2. Which of the following is the correct syntax to define a ManyToOne relation in a NestJS entity?

easy

A. @OneToOne(type => User, user => user.posts)

B. @OneToMany(type => User, user => user.posts)

C. @ManyToOne(type => User, user => user.posts)

D. @ManyToMany(type => User, user => user.posts)

Solution

1. Step 1: Recognize the relation type

   ManyToOne means many posts belong to one user.

2. Step 2: Confirm correct decorator syntax

   @ManyToOne(type => User, user => user.posts) is the correct way to define this relation.

3. Final Answer:

   @ManyToOne(type => User, user => user.posts) -> Option C

4. Quick Check:

   ManyToOne relation uses @ManyToOne decorator [OK]

Hint: ManyToOne decorator links many items to one parent [OK]

Common Mistakes:

• Using OneToMany instead of ManyToOne
• Wrong arrow function parameter name
• Missing inverse side property

3. Given these entity relations in NestJS with TypeORM:

class Student {
  @ManyToMany(() => Course, course => course.students)
  courses: Course[];
}

class Course {
  @ManyToMany(() => Student, student => student.courses)
  @JoinTable()
  students: Student[];
}

What will be the result of fetching a Course with its students included?

medium

A. A Course object with a single Student object in the 'students' property

B. A Course object with an array of Student objects in the 'students' property

C. A Course object without any students because @JoinTable is missing

D. An error because ManyToMany requires OneToMany on one side

Solution

1. Step 1: Understand ManyToMany relation with JoinTable

   ManyToMany with @JoinTable on one side creates a join table linking many students to many courses.

2. Step 2: Fetching Course includes students array

   Fetching a Course with relations loaded returns a Course object with an array of Student objects in 'students'.

3. Final Answer:

   A Course object with an array of Student objects in the 'students' property -> Option B

4. Quick Check:

   ManyToMany with @JoinTable returns array of related entities [OK]

Hint: ManyToMany with @JoinTable returns arrays on both sides [OK]

Common Mistakes:

• Expecting single object instead of array
• Forgetting @JoinTable on one side
• Confusing ManyToMany with OneToMany

4. Consider this NestJS entity code snippet:

@Entity()
class Post {
  @OneToMany(() => Comment, comment => comment.post)
  comments: Comment[];
}

@Entity()
class Comment {
  @ManyToOne(() => Post, post => post.comments)
  post: Post;
}

What is wrong if the comments property in Post is not initialized as an array?

medium

A. No issue; undefined is acceptable for relations

B. TypeORM will automatically initialize it as an empty array

C. The database schema will not be created

D. It will cause runtime errors when accessing or pushing comments

Solution

1. Step 1: Recognize relation property type

   comments is an array of Comment entities, so it should be initialized to avoid undefined.

2. Step 2: Understand runtime behavior

   If not initialized, accessing or pushing to comments causes runtime errors like 'cannot read property push of undefined'.

3. Final Answer:

   It will cause runtime errors when accessing or pushing comments -> Option D

4. Quick Check:

   Uninitialized array relation causes runtime errors [OK]

Hint: Always initialize OneToMany arrays to avoid runtime errors [OK]

Common Mistakes:

• Assuming TypeORM auto-initializes arrays
• Ignoring runtime errors from undefined arrays
• Confusing property initialization with database schema

5. You want to model a social media app where users can follow many other users and be followed by many users. Which NestJS TypeORM relation setup correctly models this ManyToMany self-referencing relation?

hard

A. @Entity()
class User {
@ManyToMany(() => User, user => user.followers)
@JoinTable()
following: User[];

@ManyToMany(() => User, user => user.following)
followers: User[];
}

B. @Entity()
class User {
@OneToMany(() => User, user => user.followers)
following: User[];

@ManyToOne(() => User, user => user.following)
followers: User[];
}

C. @Entity()
class User {
@ManyToOne(() => User, user => user.followers)
following: User[];

@OneToMany(() => User, user => user.following)
followers: User[];
}

D. @Entity()
class User {
@ManyToMany(() => User)
@JoinTable()
following: User[];

@ManyToMany(() => User)
followers: User[];
}

Solution

1. Step 1: Understand self-referencing ManyToMany

   Users follow many users and are followed by many users, so a ManyToMany self-relation is needed.

2. Step 2: Correctly set inverse sides and JoinTable

   @Entity()
   class User {
     @ManyToMany(() => User, user => user.followers)
     @JoinTable()
     following: User[];
   
     @ManyToMany(() => User, user => user.following)
     followers: User[];
   }

   uses @ManyToMany with inverse sides and @JoinTable on one side, correctly modeling the relation.

3. Final Answer:

   Code snippet with @ManyToMany, inverse sides, and @JoinTable -> Option A

4. Quick Check:

   Self-referencing ManyToMany needs inverse sides and one @JoinTable [OK]

Hint: Self ManyToMany needs inverse sides and one @JoinTable [OK]

Common Mistakes:

• Using OneToMany or ManyToOne for many-to-many
• Missing inverse side property
• Missing @JoinTable on one side