Learn NestJS - Data Access & Persistence

#Introduction

Real applications almost always need to store data. NestJS provides official integration for various ORMs, and this episode will guide you in choosing and using one. We'll focus on TypeORM because it's the most common, then touch on Prisma and Sequelize.

With data access mastered, you can build applications that are truly useful — not just endpoints returning static data.

#Choosing an ORM

#TypeORM vs Sequelize vs Prisma

These three ORMs are the main choices in the NestJS ecosystem:

• TypeORM: decorator-based, matches the NestJS style well, supports many databases.
• Sequelize: model-based, classic Object-Relational Mapping.
• Prisma: schema-first with very strict type safety and clean queries.

For this series we use TypeORM because its integration with NestJS decorators is the smoothest.

#Install TypeORM and a Driver

npm install @nestjs/typeorm typeorm sqlite3

For PostgreSQL, replace sqlite3 with pg. The @nestjs/typeorm package is the official wrapper that integrates TypeORM into NestJS.

#TypeORM Configuration

#TypeOrmModule.forRoot

Add the configuration to the root module:

Konfigurasi TypeOrmModule

import { Module } from "@nestjs/common";
import { TypeOrmModule } from "@nestjs/typeorm";
 
@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: "sqlite",
      database: "data.sqlite",
      autoLoadEntities: true,
      synchronize: true,
    }),
  ],
})
export class AppModule {}

autoLoadEntities: true automatically registers entities from feature modules, and synchronize: true syncs the schema with the database — fine for development, don't use it in production.

#Entities and Migrations

#Defining an Entity

An entity is a class that represents a table:

Definisi entity User

import { Column, Entity, PrimaryGeneratedColumn } from "typeorm";
 
@Entity("users")
export class User {
  @PrimaryGeneratedColumn()
  id: number;
 
  @Column()
  name: string;
 
  @Column({ unique: true })
  email: string;
}

The @Entity("users") decorator maps the class to the users table, @PrimaryGeneratedColumn for the auto-increment primary key, and @Column for columns.

#Migrations

synchronize is only for development. For production, use migrations that generate the schema in a controlled way:

npm run typeorm -- migration:generate src/migrations/Init --dataSource src/data-source.ts

Migrations keep a history of schema changes so they can be applied to every environment consistently and can be rolled back.

#Repository Pattern

#Injecting a Repository

TypeORM provides the repository pattern via @InjectRepository:

Menggunakan repository di service

import { Injectable } from "@nestjs/common";
import { InjectRepository } from "@nestjs/typeorm";
import { Repository } from "typeorm";
import { User } from "./user.entity";
 
@Injectable()
export class UsersService {
  constructor(
    @InjectRepository(User)
    private readonly usersRepository: Repository<User>,
  ) {}
 
  create(name: string, email: string): Promise<User> {
    const user = this.usersRepository.create({ name, email });
    return this.usersRepository.save(user);
  }
 
  findAll(): Promise<User[]> {
    return this.usersRepository.find();
  }
}

Repositories provide ready-to-use methods: find, findOne, save, update, delete, and many more. To make the repository injectable, register the entity via TypeOrmModule.forFeature([User]) in the feature module's imports array.

#Query Builder

#Dynamic Queries

For complex queries, TypeORM provides the query builder:

Query builder dengan filter

async findActiveByName(name: string): Promise<User[]> {
  return this.usersRepository
    .createQueryBuilder("user")
    .where("user.name LIKE :name", { name: `%${name}%` })
    .andWhere("user.isActive = :active", { active: true })
    .orderBy("user.id", "DESC")
    .take(10)
    .getMany();
}

The query builder gives you full control over the generated SQL: joins, subqueries, aggregations, and pagination. The :name parameter prevents SQL injection because it uses parameter binding.

#In-Memory Databases

For testing, an in-memory database is very practical because it never touches the disk:

TypeORM dengan database in-memory

TypeOrmModule.forRoot({
  type: "sqlite",
  database: ":memory:",
  autoLoadEntities: true,
  synchronize: true,
})

The value ":memory:" makes the database run in RAM and disappear when the process ends — perfect for fast, isolated unit tests.

#Conclusion

Episode 6 takes you from zero to data actually being stored: choosing an ORM, TypeORM configuration, defining entities, migrations, the repository pattern, the query builder, and in-memory databases.

Key takeaways:

• TypeORM is the primary choice because it fits the NestJS decorator style.
• TypeOrmModule.forRoot configures the database connection.
• Entities map classes to tables using TypeORM decorators.
• synchronize is only for development; production uses migrations.
• The repository pattern is used via @InjectRepository.
• The query builder gives full control with safe parameter binding.

In the next episode 7 we'll discuss validation and exception handling — validation with class-validator and class-transformer, global pipes, custom validation pipes, exception filters, and standardizing error responses.