Using Nest.js with PostgreSQL: A Comprehensive Guide

In this article, we'll explore how to use Nest.js with PostgreSQL, a popular Node.js framework and a powerful relational database management system. We'll cover the basics of setting up a Nest.js project, installing the required dependencies, and configuring the PostgreSQL database. We'll also dive into creating a simple CRUD (Create, Read, Update, Delete) application using Nest.js and PostgreSQL.

Prerequisites

To follow along with this guide, you'll need to have the following installed on your machine:

• Node.js (version 14 or higher)
• NPM (version 6 or higher)
• PostgreSQL (version 12 or higher)
• A code editor or IDE of your choice

Setting up a Nest.js Project

To create a new Nest.js project, run the following command in your terminal:

npm i -g @nestjs/cli
nest new nest-postgres

This will create a new Nest.js project called `nest-postgres`. Navigate into the project directory:

cd nest-postgres

Installing Dependencies

To use PostgreSQL with Nest.js, we'll need to install the `@nestjs/typeorm` and `pg` packages. Run the following command:

npm install --save @nestjs/typeorm pg

Configuring the PostgreSQL Database

Create a new file called `database.ts` in the `src` directory:

import { TypeOrmModuleOptions } from '@nestjs/typeorm';

export const databaseConfig: TypeOrmModuleOptions = {
  type: 'postgres',
  host: 'localhost',
  port: 5432,
  username: 'your_username',
  password: 'your_password',
  database: 'your_database',
  entities: [__dirname + '/../**/*.entity{.ts,.js}'],
  synchronize: true,
};

Replace the placeholders with your actual PostgreSQL database credentials and database name.

Creating a Simple CRUD Application

Create a new file called `user.entity.ts` in the `src` directory:

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

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

  @Column()
  name: string;

  @Column()
  email: string;
}

Create a new file called `users.module.ts` in the `src` directory:

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { User } from './user.entity';
import { UsersService } from './users.service';
import { UsersController } from './users.controller';

@Module({
  imports: [TypeOrmModule.forFeature([User])],
  providers: [UsersService],
  controllers: [UsersController],
})
export class UsersModule {}

Create a new file called `users.service.ts` in the `src` directory:

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 userRepository: Repository<User>,
  ) {}

  async findAll(): Promise<User[]> {
    return this.userRepository.find();
  }

  async create(user: User): Promise<User> {
    return this.userRepository.save(user);
  }

  async update(id: number, user: User): Promise<User> {
    const existingUser = await this.userRepository.findOne(id);
    if (!existingUser) {
      throw new Error('User not found');
    }
    return this.userRepository.save({ ...existingUser, ...user });
  }

  async delete(id: number): Promise<void> {
    await this.userRepository.delete(id);
  }
}

Create a new file called `users.controller.ts` in the `src` directory:

import { Controller, Get, Post, Put, Delete, Body, Param } from '@nestjs/common';
import { UsersService } from './users.service';

@Controller('users')
export class UsersController {
  constructor(private readonly usersService: UsersService) {}

  @Get()
  async findAll(): Promise<User[]> {
    return this.usersService.findAll();
  }

  @Post()
  async create(@Body() user: User): Promise<User> {
    return this.usersService.create(user);
  }

  @Put(':id')
  async update(@Param('id') id: number, @Body() user: User): Promise<User> {
    return this.usersService.update(id, user);
  }

  @Delete(':id')
  async delete(@Param('id') id: number): Promise<void> {
    return this.usersService.delete(id);
  }
}

Running the Application

Start the Nest.js application by running the following command:

npm run start:dev

Use a tool like Postman or cURL to test the CRUD endpoints.

Conclusion

In this guide, we've covered how to use Nest.js with PostgreSQL to create a simple CRUD application. We've installed the required dependencies, configured the PostgreSQL database, and created a simple CRUD application using Nest.js and TypeORM.

Frequently Asked Questions

What is Nest.js?

Nest.js is a Node.js framework for building efficient, scalable, and maintainable server-side applications.

What is PostgreSQL?

PostgreSQL is a powerful, open-source relational database management system.

What is TypeORM?

TypeORM is a TypeScript-based Object-Relational Mapping (ORM) library for working with databases.

How do I install the required dependencies?

Run the command `npm install --save @nestjs/typeorm pg` to install the required dependencies.

How do I configure the PostgreSQL database?

Create a new file called `database.ts` and export a `TypeOrmModuleOptions` object with your database credentials and configuration.