DEV Community: Refi Fauzan

NestJS with TypeORM and PostgreSQL

Refi Fauzan — Sat, 22 Mar 2025 18:51:38 +0000

Introduction

TypeORM is an Object-Relational Mapping (ORM) that can be used in NodeJS. It is a good fit for NestJS application. TypeORM stands out as the only JavaScript ORM that supports both Active Record and Data Mapper patterns. This unique feature allows developers to create high-quality, scalable, and maintainable applications in the most efficient manner. TypeORM support lots of DBMS (Database Management System) such as PostgreSQL, MySQL, SQLite, and etc.

So in this article I will share how to install and setup TypeORM in NestJS application with PostgreSQL.

So first of all you need to create NestJS application:

nest new <application-name>

After you create NestJS application you need to install this library:

npm i --save @nestjs/config dotenv

that library is to loads environment variable from .env file.

After you install the library you can create .env file:

NODE_ENV=development

DB_USERNAME="dev"
DB_PASSWORD="dev@developer"
DB_NAME="database_name"
DB_HOST="localhost"
DB_PORT=5432
DB_SEEDER="false"
DB_SYNCRONIZE="false"

and you can add this in app.module.ts:

imports: [
  ConfigModule.forRoot({
    envFilePath: '.env',
    isGlobal: true,
  })
]

After that you can install TypeORM library and its extension:

npm i --save @nestjs/typeorm typeorm pg typeorm-extension typeorm-naming-strategies

typeorm - is a TypeORM library.
pg - is a PostgreSQL client connection library.
typeorm-extension - is a library for seed the database.
typeorm-naming-strategies - is a library for changing naming convention to follow best practice naming convention of PostgreSQL

Now you can add the database configuration and connection in src/config/database.config.ts:

import { DataSource, DataSourceOptions } from 'typeorm';
import * as dotenv from 'dotenv';
import { SnakeNamingStrategy } from 'typeorm-naming-strategies';
import { SeederOptions } from 'typeorm-extension';

dotenv.config();

export const dataSourceOptions: DataSourceOptions & SeederOptions = {
  type: 'postgres',
  username: process.env.DB_USERNAME,
  password: process.env.DB_PASSWORD,
  database: process.env.DB_NAME,
  port: +process.env.DB_PORT,
  host: process.env.DB_HOST,
  entities: [
    'dist/api/**/*.entity{.ts,.js}',
  ],
  migrations: ['dist/database/migrations/*{.ts,.js}'],
  seeds: ['dist/database/seeds/*{.ts,.js}'],
  factories: ['dist/database/factories/**/*{.ts,.js}'],
  seedTracking: false,
  synchronize: process.env.DB_SYNCHRONIZE === 'true',
  logging: process.env.NODE_ENV === 'development',
  namingStrategy: new SnakeNamingStrategy(),
  cache: true,
};

const dataSource = new DataSource(dataSourceOptions);
export default dataSource;

dataSource.initialize();

in code above is to initialize the data source, data source is pre-defined connection configuration to a specific database.

After you create the file above, you can register it in app.module.ts file:

imports: [
  TypeOrmModule.forRoot(dataSourceOptions),
]

After that you can add this following script in your package.json:

"typeorm": "npm run build && npx typeorm -d dist/config/database.config.js",
"migration:run": "npm run typeorm -- migration:run",
"migration:generate": "npm run typeorm -- migration:generate",
"migration:revert": "npm run typeorm -- migration:revert",
"migration:create": "npm run typeorm -- migration:create",
"migration:show": "npm run typeorm -- migration:show",
"migrate": "npm run typeorm migration:run -- -t=false",
"schema:sync": "npm run typeorm schema:sync",
"schema:drop": "npm run typeorm schema:drop",
"db:create": "ts-node ./node_modules/typeorm-extension/bin/cli.cjs db:create -d dist/config/database.config.js",
"db:drop": "ts-node ./node_modules/typeorm-extension/bin/cli.cjs db:drop -d dist/config/database.config.js",
"seed:run": "npm run build && ts-node -r tsconfig-paths/register ./node_modules/typeorm-extension/bin/cli.cjs seed:run -d dist/config/database.config.js --preserveFilePaths true -n",
"seed:run:all": "npm run build && ts-node -r tsconfig-paths/register ./node_modules/typeorm-extension/bin/cli.cjs seed:run -d dist/config/database.config.js",
"seed:create": "npm run build && ts-node -r tsconfig-paths/register ./node_modules/typeorm-extension/bin/cli.cjs seed:create"

Now you can create the entity file in your folder, i'll create in src/api/user/user.entity.ts:

import {
  Column,
  CreateDateColumn,
  DeleteDateColumn,
  Entity,
  PrimaryGeneratedColumn,
  UpdateDateColumn,
} from 'typeorm';

@Entity({ name: 'users' })
export class User {
  @PrimaryGeneratedColumn('uuid')
  id: string;

  @Column({ unique: true })
  email: string;

  @Column()
  firstName: string;

  @Column()
  lastName: string;

  @Column()
  password: string;

  @CreateDateColumn({ nullable: true })
  createdAt?: Date;

  @UpdateDateColumn({ nullable: true })
  updatedAt?: Date;

  @DeleteDateColumn({ nullable: true })
  deletedAt?: Date;
}

After you create the entity file, the data source will detect your file and after you run this following command it will create the migration file:

npm run migration:generate src/database/migrations/CreateUserTable

it generate this file <timestmap>-CreateUserTable.ts and here inside its file:

import { MigrationInterface, QueryRunner } from 'typeorm';

export class CreateUserTable1742662098102 implements MigrationInterface {
  name = 'CreateUserTable1742662098102';

  public async up(queryRunner: QueryRunner): Promise<void> {
    await queryRunner.query(
      `CREATE TABLE "users" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "email" character varying NOT NULL, "first_name" character varying NOT NULL, "last_name" character varying NOT NULL, "password" character varying NOT NULL, "created_at" TIMESTAMP DEFAULT now(), "updated_at" TIMESTAMP DEFAULT now(), "deleted_at" TIMESTAMP, CONSTRAINT "UQ_97672ac88f789774dd47f7c8be3" UNIQUE ("email"), CONSTRAINT "PK_a3ffb1c0c8416b9fc6f907b7433" PRIMARY KEY ("id"))`,
    );
    await queryRunner.query(
      `CREATE TABLE "query-result-cache" ("id" SERIAL NOT NULL, "identifier" character varying, "time" bigint NOT NULL, "duration" integer NOT NULL, "query" text NOT NULL, "result" text NOT NULL, CONSTRAINT "PK_6a98f758d8bfd010e7e10ffd3d3" PRIMARY KEY ("id"))`,
    );
  }

  public async down(queryRunner: QueryRunner): Promise<void> {
    await queryRunner.query(`DROP TABLE "query-result-cache"`);
    await queryRunner.query(`DROP TABLE "users"`);
  }
}

After you generate the file migration now you can run the migration by this command:

npm run migration:run

and if you want to create seeder you can use this command:

npm run seed:create -n src/database/seeds/user

it will generate this file <timestamp>-user.ts and here inside the file:

import { DataSource } from 'typeorm';
import { Seeder, SeederFactoryManager } from 'typeorm-extension';

export class User1742663731380 implements Seeder {
  track = false;

  public async run(
    dataSource: DataSource,
    factoryManager: SeederFactoryManager,
  ): Promise<any> {}
}

i will add seed 3 users and the code will be like this:

mport { User } from 'src/api/user/user.entity';
import { DataSource } from 'typeorm';
import { Seeder, SeederFactoryManager } from 'typeorm-extension';
import * as bcrypt from 'bcrypt';

export class User1742663731380 implements Seeder {
  track = false;

  public async run(
    dataSource: DataSource,
    factoryManager: SeederFactoryManager,
  ): Promise<any> {
    const user = dataSource.getRepository(User);
    const hash = await bcrypt.hash('Password@123', 10);
    await user.save([
      {
        firstName: 'Dadang',
        lastName: 'Jebred',
        email: 'dadang@jebred.com',
        password: hash,
      },
      {
        firstName: 'Atin',
        lastName: 'Mustofa',
        email: 'atin@mustofa.com',
        password: hash,
      },
      {
        firstName: 'Vina',
        lastName: 'Vini',
        email: 'vino@dadang.com',
        password: hash,
      },
    ]);
  }
}

then you can run this command to run the seeder:

npm run seed:run <timestamp>-user.js

and thats it. Make sure the path location of data source in package.json is match.

Hopefully, this helps you. If you have any questions, feel free to comment below and see you in another article 👋.

Make your response consistent in NestJS using Interceptors

Refi Fauzan — Wed, 06 Nov 2024 02:41:05 +0000

Introduction

As a backend developer consistent responses are important to make your client can easily interact with API you’ve made. Without a standard structure, responses felt chaotic, make it harder to debug and for others to work with the data. To handle this, I explored ways to make my responses clean and predictable. Along the way, I learned about some helpful technique it called Interceptors that made a big difference. I’ll share what I learned about keeping API responses consistent in NestJS, make it easier for everyone to work with my API.

Standardize your API

Before you create an API, it’s essential to establish a clear standardization plan. This helps ensure consistency, readability, and ease of use for developers interacting with it. Most of modern APIs today use the RESTful approach, which is stand for (Representational State Transfer). RESTful APIs follow a set of architectural principles that make them scalable, flexible and easy to understand. We will talk about RESTful API later.

What is NestJS Interceptors?

In NestJS Interceptors are like helper function that sit in the middle of request and response of process in you application, it sounds like same as middleware but middleware is called only before the request reaches to the controller and also middleware can only handle the request.

Let’s standardize our API

I want the the API response if it return success it should be like this:

{
    "statusCode": 200,
    "message": "Data get successfully",
    "data": [...],
}

But if it failed or error it should be like this:

{
    "statusCode": 500,
    "message": "Internal Server Error",
    "error": "InternalServerErrorException",
    "timestamp": 1730691956164,
    "data": {}
}

note: if you want to catch everything you can using Global Exception Filter, that I will talk about it later.

Defining an Interceptors

First of all you can follow this steps:

Create new file for handling the response interceptors

I named it response.interceptor.ts it located on src/client/response.interceptor.ts

Then Create the response interceptor class that implements to NestInterceptor

@Injectable()
export class ResponseInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observalble<any> {
    return next.handle().pipe();
  }
}

The intercept method takes two arguments. The first is ExecutionContext , which provides information about the current request and what’s happening in the request process. And the second is CallHandler which includes a handle() method that you can call to run the function that actually processes the request. Intercept allows you to check details of the request and then call the handler when needed.

Don’t forget to import the required module

import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
import { Observable } from 'rxjs';
import { map } from 'rxjs/operators';

Then mapping the response

return next.handle().pipe(
  map((data) => {     
    // mapping your response here
  })
)

The data value is returned by your route handler which means return value of your controller.

The interceptor required to register inside your application by registering as provider in app.module.ts .

Now you can manipulate the response

If you want to change the message each of HTTP Method you implementing like this :

....
const response = context.switchToHttp().getResponse();
const statusCode = response.statusCode;
const httpMethod: unknown = context.switchToHttp().getRequest().method;

let message: unknown = '';

return next.handle().pipe(
  map((data) => {
    switch (httpMethod) {
      case 'GET':
        message = 'Data get successfully';
        break;
      case 'POST':
        message = 'Data created successfully';
        break;
      case 'PATCH':
      case 'PUT':
        message = 'Data updated successfully';
        break;
      case 'DELETE':
        message = 'Data deleted successfully';
        break;
      default:
        message = 'Successfully';
        break;
    }

    return {
      statusCode,
      message,
      data
    }
  })
)
....

from that approach it return the response like this :

{
    "statusCode": 200,
    "message": "Data get successfully",
    "data": "Hello World!"
}

now it same as we expected before. But take a look closer inside the switch case :

switch (httpMethod) {
  case 'GET':
    message = 'Data get successfully';
    break;
  case 'POST':
    message = 'Data created successfully';
    break;
  case 'PATCH':
  case 'PUT':
    message = 'Data updated successfully';
    break;
  case 'DELETE':
    message = 'Data deleted successfully';
    break;
  default:
    message = 'Successfully';
    break;
}

all message it successfully what happen if the response returned an error or failed? it would be like this?

{
  "statusCode": 500,
  "message": "Data get successfully",
  "data": null
}

No, it will not like that, by default when have exception it will handle by HttpException which is build-in exception filter provided by NestJS. So the response will be like this :

{
   "message": "Internal Server Error",
   "statusCode": 500
}

So how do I manipulate the exception response?

You can add catchError() method inside the pipe().
The catchError() method is to catches errors on the observable.

catchError((err) => {
  const statusCode = err instanceof HttpException ? err.getStatus() : 500;
  const errorResponse = {
    statusCode,
    message: err.message || new InternalServerErrorException(),
    error: err.name || 'Error',
    timestamp: Date.now(),
    data: {},
   };

   return throwError(() => new HttpException(errorResponse, statusCode));
}),

the code above it to change the response when it got an exception or got an error. Now the response will be something like this :

{
  "statusCode": 500,
  "message": "Internal Server Error",
  "error": "InternalServerErrorException",
  "timestamp": 1730706189471,
  "data": {}
}

Thats it.

Here the whole code of ResponseInterceptor class that we’ve made :

import {
  Injectable,
  NestInterceptor,
  ExecutionContext,
  CallHandler,
  HttpException,
  InternalServerErrorException,
} from '@nestjs/common';
import { Observable, throwError } from 'rxjs';
import { map, catchError } from 'rxjs/operators';

@Injectable()
export class ResponseInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    const response = context.switchToHttp().getResponse();
    const statusCode = response.statusCode;
    const httpMethod: unknown = context.switchToHttp().getRequest().method;

    let message: unknown = '';

    return next.handle().pipe(
      map((data) => {
        switch (httpMethod) {
          case 'GET':
            message = 'Data get successfully';
            break;
          case 'POST':
            message = 'Data created successfully';
            break;
          case 'PATCH':
          case 'PUT':
            message = 'Data updated successfully';
            break;
          case 'DELETE':
            message = 'Data deleted successfully';
            break;
          default:
            message = 'Success';
            break;
        }

        return {
          statusCode,
          message,
          data,
        };
      }),
      catchError((err) => {
        const statusCode = err instanceof HttpException ? err.getStatus() : 500;
        const errorResponse = {
          statusCode,
          message: err.message || new InternalServerErrorException(),
          error: err.name || 'Error',
          timestamp: Date.now(),
          data: {},
        };
        return throwError(() => new HttpException(errorResponse, statusCode));
      }),
    );
  }
}

The interceptors is a useful helper it can manipulate your response, logging or monitoring, transforming requests and a lot more. That I will talk about it later.