Mastering Database Operations with TypeORM and NestJS: A Beginner-Friendly Guide

Learn how to seamlessly integrate TypeORM with NestJS to simplify database operations. This beginner-friendly guide covers setup, creating entities, and performing CRUD operations in a structured and efficient way!

Imagine your favorite toy collection needs organizing. Each toy has a name, color, and size. Now, imagine you want to save this collection in a super-organized notebook that you can look at anytime. TypeORM and NestJS together are like that notebook, helping you save and organize information about your toys—or in our case, real-world data—into a database.

In this blog, I’ll show you how to use TypeORM with NestJS to manage a database. It’s super simple, and by the end, you’ll feel like a database superhero!

---

What Is TypeORM?

TypeORM is like a magic tool that helps you work with databases without needing to write tricky commands. Instead of writing complex database instructions, you can use simple TypeScript or JavaScript code.

Think of TypeORM as your translator—it takes your code and converts it into a language that databases understand.

---

Setting Up NestJS with TypeORM

Step 1: Install the Necessary Tools

Before starting, make sure you have Node.js and NestJS installed. Then, install TypeORM and the database package you’ll use (e.g., PostgreSQL, MySQL).

npm install @nestjs/typeorm typeorm pg

Here, pg is for PostgreSQL. Replace it with mysql or another database driver if you’re using a different database.

---

Step 2: Configure TypeORM in NestJS

TypeORM needs some information to connect to your database. This is like giving your phone the Wi-Fi password to connect to the internet.

Add the following to app.module.ts:

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';

@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: 'postgres', // Replace with your database type
      host: 'localhost',
      port: 5432, // Default port for PostgreSQL
      username: 'your_username',
      password: 'your_password',
      database: 'your_database_name',
      autoLoadEntities: true, // Automatically load entities
      synchronize: true, // Sync database schema (use only in development)
    }),
  ],
})
export class AppModule {}

---

Step 3: Create an Entity

An entity is like a blueprint for your database. Imagine you’re saving details about your toys. You’d need fields like name, color, and size. Let’s create an entity for that:

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

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

  @Column()
  name: string;

  @Column()
  color: string;

  @Column()
  size: string;
}

---

Step 4: Create a Service to Handle Database Operations

Services are like helpers in NestJS. Let’s create one to save, fetch, and manage toys.

import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { Toy } from './toy.entity';

@Injectable()
export class ToyService {
  constructor(
    @InjectRepository(Toy)
    private toyRepository: Repository<Toy>,
  ) {}

  createToy(toyData: Partial<Toy>) {
    const newToy = this.toyRepository.create(toyData);
    return this.toyRepository.save(newToy);
  }

  findAllToys() {
    return this.toyRepository.find();
  }

  findToyById(id: number) {
    return this.toyRepository.findOneBy({ id });
  }

  deleteToy(id: number) {
    return this.toyRepository.delete(id);
  }
}

---

Step 5: Connect Everything with a Controller

Controllers are like buttons on a toy—when you press a button, something happens.

import { Controller, Get, Post, Body, Param, Delete } from '@nestjs/common';
import { ToyService } from './toy.service';

@Controller('toys')
export class ToyController {
  constructor(private readonly toyService: ToyService) {}

  @Post()
  createToy(@Body() toyData) {
    return this.toyService.createToy(toyData);
  }

  @Get()
  findAllToys() {
    return this.toyService.findAllToys();
  }

  @Get(':id')
  findToyById(@Param('id') id: number) {
    return this.toyService.findToyById(id);
  }

  @Delete(':id')
  deleteToy(@Param('id') id: number) {
    return this.toyService.deleteToy(id);
  }
}

---

Interview Questions and Answers

1. What is TypeORM in NestJS?
   • Answer: TypeORM is an Object-Relational Mapping (ORM) library that helps interact with databases using TypeScript or JavaScript instead of writing raw SQL queries.
2. How do you integrate TypeORM into a NestJS application?
   • Answer: You integrate TypeORM by importing TypeOrmModule into the root module and providing connection details in the TypeOrmModule.forRoot() method.
3. What is an entity in TypeORM?
   • Answer: An entity is a class that represents a table in the database. Each property in the class corresponds to a column in the table.
4. What does the synchronize option do in TypeORM?
   • Answer: The synchronize option automatically updates the database schema to match the entities. It should only be used in development, not in production.
5. What are repositories in TypeORM?
   • Answer: Repositories are objects provided by TypeORM to interact with database tables, allowing CRUD operations.

---

Companies That Ask About TypeORM with NestJS

1. TCS
2. Infosys
3. Capgemini
4. Accenture
5. Tech Mahindra
6. Cognizant

---

Conclusion

Working with databases can be fun and straightforward when you use TypeORM and NestJS. By following the steps above, you can create, read, update, and delete data with ease. If you’re preparing for interviews, understanding these concepts and practicing them will make you stand out!

Interested in learning more about Microservices and NestJS? Check out our latest blogs for more in-depth guides, tutorials, and best practices on building scalable applications with NestJS and microservices.