DEV Community: Henry

Mastering TypeORM Relationships in NestJS: A Complete Guide

Henry — Fri, 25 Apr 2025 08:40:44 +0000

One of the superpowers of building with NestJS is how seamlessly it integrates with TypeORM, giving developers a clean, structured way to model database relationships using decorators and entities.

But while getting started with basic models is easy, understanding relationships—how tables/entities connect—is where things get more interesting, and sometimes confusing.

In this post, we’ll break down how to model and use relationships in TypeORM with NestJS, covering the following:

One-to-One
One-to-Many / Many-to-One
Many-to-Many
How to use relations in services
How to load related data
Tips and pitfalls

Let’s dive in.

What is a Relationship in TypeORM?

In database design, a relationship is how tables (or entities in ORM) connect. Think:

A user has one profile
A post has many comments
A student can be enrolled in many courses, and vice versa

These connections are defined using relation decorators like @OneToOne, @ManyToOne, @OneToMany, and @ManyToMany in TypeORM.

Setting Up: Example Models

We’ll use the example of a blogging system, with User, Post, and Comment entities.

npm install --save @nestjs/typeorm typeorm

1. One-to-One: User & Profile

Scenario:

Each user has one profile. Each profile belongs to one user.

User Entity

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

  @Column()
  username: string;

  @OneToOne(() => Profile, (profile) => profile.user, { cascade: true })
  @JoinColumn()
  profile: Profile;
}

Profile Entity

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

  @Column()
  bio: string;

  @OneToOne(() => User, (user) => user.profile)
  user: User;
}

Note: @JoinColumn() is used on the side that owns the relationship.

2. One-to-Many / Many-to-One: Post & Comment

Scenario:

One post can have many comments. Each comment belongs to one post.

Post Entity

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

  @Column()
  title: string;

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

Comment Entity

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

  @Column()
  content: string;

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

This is probably the most commonly used relationship in apps: a user has many posts, an order has many items, etc.

3. Many-to-Many: Students & Courses

Scenario:

A student can be enrolled in many courses. A course can have many students.

Student Entity

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

  @Column()
  name: string;

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

Course Entity

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

  @Column()
  title: string;

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

Use @JoinTable() on one side only to define the owning side of the relationship.

Loading Relationships in Services

In your services, you can load related entities using the relations option in find or findOne.

Example:

// post.service.ts
findAll() {
  return this.postRepository.find({
    relations: ['comments'],
  });
}

Nested Relations:

this.userRepository.find({
  relations: ['profile', 'posts', 'posts.comments'],
});

This is powerful for loading deeply nested related data in one go.

Creating and Saving Relationships

You can also save entities with their relations using cascade options:

const user = this.userRepository.create({
  username: 'john_doe',
  profile: {
    bio: 'Fullstack dev',
  },
});

await this.userRepository.save(user);

Make sure you set cascade: true on the relation if you're doing this.

Pitfalls & Best Practices

Don’t overfetch: Only include relations you need. Too many joins = slow queries.
Use DTOs: Don’t expose raw entities in your controllers. Transform them into DTOs.
Avoid circular relations in JSON: Be careful when returning nested entities—you can easily create circular JSON references.
Use transactions: When saving deeply nested relationships that depend on each other, wrap in a transaction.
Always index foreign keys: Speeds up joins significantly.

In Summary

TypeORM relationships + NestJS provide a declarative and powerful way to work with relational databases.

To recap:

Use @OneToOne, @OneToMany, @ManyToOne, and @ManyToMany to model relationships.
Use relations in .find() queries to pull in related data.
Use cascade when saving nested entities.
Always structure your data flow using services and DTOs, not raw entities.

Thanks for reading!.

Why Your Company Needs a Blog (Yes, Even Yours)

Henry — Fri, 25 Apr 2025 08:31:09 +0000

There’s something special about scrolling through a company’s blog and realizing… these people care. They’re not just building a product. They’re thinking deeply. They’re learning in public. They’re transparent when things break. They’re proud of their process.

That’s the kind of feeling I get every time I read Monzo’s engineering blog. It’s not just techy. It’s honest. Thoughtful. Real. And it made me wonder—why don’t more companies do this?

So here’s the case, plain and simple: your company—no matter how big or small—needs a blog.

And not just because “content marketing is good for SEO” (though it is). But because your blog can be the soul of your business, showing the world who you are, how you think, and what you care about.

Let me explain.

1. A Blog Builds Trust

People don’t just buy products. They buy into people. They follow stories. They root for progress.

When you write about the hard stuff—how your team fixed a production bug at 2am, or why you chose one approach over another—you let customers in. You’re not just a faceless company anymore. You’re human.

That trust? It compounds.

2. A Blog Helps People Find You

Let’s talk visibility.

Blog posts—real, useful, authentic ones—live forever. They show up in Google searches. They get shared. They start conversations. One post can bring in traffic, leads, and talent months or even years after you hit publish.

You don’t need to write clickbait or chase trends. Just write what you know. Share what you’re learning. The right people will find you.

3. A Blog Attracts the Right Talent

You know what the best engineers, designers, and marketers all have in common? They care about how things are built, not just what is built.

Your blog is a window into your company’s brain. It shows potential hires what kind of problems you solve, how your team communicates, and what kind of place they’d be joining.

It's like passive recruiting—but way more authentic.

4. Writing Makes You Smarter

This one might be my favorite.

When someone on your team writes about a technical challenge or a product decision, they’re forced to slow down. Think clearly. Get to the essence of the idea.

Writing is a forcing function for clarity. And it often sparks better internal conversations, too. Your blog becomes a reflection of your culture of thinking.

5. It’s Yours Forever

Social media platforms rise and fall. Algorithms change. But your blog is your own space. Your words. Your domain.

You can write about outages, product decisions, hiring philosophies, lessons learned, even team rituals. It becomes an archive of your journey—one that grows more valuable with time.

"But What Would We Even Write About?"

Glad you asked. Here’s a quick brainstorm:

How we fixed that one bug that broke everything
Why we rewrote our backend in Go
What we learned from launching too early (or too late)
How we do support as a small team
Our favorite tools (and why we use them)
What we’re reading as a team this month
The day everything went wrong—and what it taught us

Start small. Be honest. Keep it conversational. The best posts feel like a story told over coffee.

In Closing…

A blog isn’t a marketing tactic. It’s a mirror—a reflection of your thinking, your values, your progress.

It builds trust. It makes you discoverable. It attracts the people you want to work with. And most importantly, it reminds you—and your team—why you’re doing this in the first place.

So start writing, curious kids like I could get lot of help reading them.

Starting over as a backend Engineer

Henry — Mon, 14 Apr 2025 22:15:20 +0000

The best way to write is to start writing - Anonymous
It’s been 5 years I wrote my first program in C, then hop into PHP, HTML, CSS and JavaScript. Unfortunately I stoked to JavaScript, and evolved to Typescript following my love for something typed.

The journey got tense with ReactJs, Nestjs seriously there are a lot to learn in the JavaScript workspace. Unfortunately I chose to stick with the backend side of things focusing on building secure API delving into REST API and GraphQL, looking to checkout Grpc, Kafka, Redis e.t.c

Learned a lot about scaling a backend service, knowing the why for a distributed system in scaling backend services.

Frankly speaking backend is FUN.