Relations (OneToMany, ManyToOne, ManyToMany) in NestJS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this NestJS entity relation setup?

Given these two entities in NestJS using TypeORM, what will be the result of fetching a Post with its comments?

NestJS

import { Entity, PrimaryGeneratedColumn, Column, OneToMany, ManyToOne } from 'typeorm';

@Entity()
export class Post {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  title: string;

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

@Entity()
export class Comment {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  text: string;

  @ManyToOne(() => Post, post => post.comments)
  post: Post;
}

// Assume a Post with id=1 has 3 comments linked.
// What will be the value of post.comments after fetching Post with id=1 including relations?

A Undefined, because OneToMany does not load relations automatically

B An empty array because relations are not set up correctly

C A single Comment object instead of an array

D An array of 3 Comment objects linked to the Post

💡 Hint

Remember that OneToMany defines a collection of related entities.

The OneToMany decorator creates a property that holds an array of related entities. When fetching a Post with its comments relation loaded, post.comments will be an array containing all linked Comment objects.

📝 Syntax

intermediate

Which option correctly defines a ManyToMany relation in NestJS with TypeORM?

Choose the correct syntax to define a ManyToMany relation between User and Role entities with a join table.

A

@ManyToMany(Role)
@JoinTable
roles: Role[];

B

@ManyToMany(() => Role, role => role.users)
@JoinTable()
roles: Role[];

C

@ManyToMany(() => Role, role => role.users)
roles: Role[];

D

@ManyToMany(() => Role)
@JoinTable()
roles: Role[];

💡 Hint

Remember to use a function returning the class and to add @JoinTable() on one side.

Option B correctly uses a function returning the Role class, defines the inverse side, and includes @JoinTable() to create the join table. Option B misses the inverse side, B has wrong syntax, and C misses @JoinTable().

🔧 Debug

advanced

Why does this ManyToOne relation cause a runtime error?

Consider this entity code snippet:

import { Entity, PrimaryGeneratedColumn, Column, ManyToOne } from 'typeorm';
import { Category } from './category.entity';

@Entity()
export class Product {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  name: string;

  @ManyToOne(Category)
  category: Category;
}

When running the app, it throws an error about missing function in relation definition. What is the cause?

A The @Column decorator is missing on the category property

B The Category entity is missing a primary key

C The relation decorator should use a function returning the class: @ManyToOne(() => Category)

D The Product entity must import Category with a relative path

💡 Hint

Check how the relation decorator references the related class.

TypeORM requires the relation decorator to receive a function returning the class, not the class directly. Using @ManyToOne(Category) causes a runtime error because it expects a function like @ManyToOne(() => Category).

❓ state_output

advanced

What is the state of the database after saving these entities with ManyToMany relation?

Given these entities and code:

import { Entity, PrimaryGeneratedColumn, Column, ManyToMany, JoinTable } from 'typeorm';

@Entity()
export class Student {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  name: string;

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

@Entity()
export class Course {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  title: string;

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

// Code snippet:
const student = new Student();
student.name = 'Alice';

const course1 = new Course();
course1.title = 'Math';

const course2 = new Course();
course2.title = 'Science';

student.courses = [course1, course2];

await studentRepository.save(student);

What will be saved in the database?

A Only the student 'Alice' is saved; courses are not saved automatically

B Student 'Alice' saved with two new courses 'Math' and 'Science' and join table entries linking them

C Courses are saved but the join table linking student and courses is empty

D An error occurs because courses are not saved before assigning

💡 Hint

TypeORM does not cascade saves by default for relations.

Since no cascade: true is specified on the ManyToMany relation, calling save(student) only persists the Student entity. The new Course instances are not saved, and thus no join table entries are created.

🧠 Conceptual

expert

Which statement best describes the difference between OneToMany and ManyToOne in NestJS TypeORM?

Choose the most accurate explanation of how OneToMany and ManyToOne decorators relate entities in NestJS with TypeORM.

A <code>ManyToOne</code> defines the owning side and stores the foreign key column, while <code>OneToMany</code> is inverse and does not store the key.

B <code>OneToMany</code> and <code>ManyToOne</code> are interchangeable and both store foreign keys.

C Both <code>OneToMany</code> and <code>ManyToOne</code> store foreign keys independently in their tables.

D <code>OneToMany</code> defines the owning side of the relation and stores the foreign key, while <code>ManyToOne</code> is inverse and does not store the key.

💡 Hint

Think about which side owns the foreign key column in the database.

In TypeORM, the ManyToOne side is the owning side and stores the foreign key column in its table. The OneToMany side is inverse and does not store the foreign key. This is important for how relations are saved and queried.