Configuring Database Connection

Oct 13, 2025 by thesweetdesigns.com 21 views

Introduction

Establishing a robust connection to a database is a crucial step in building a scalable and efficient application. In this article, we will explore how to implement a database connection using TypeORM and NestJS. We will cover the configuration of a connection to a PostgreSQL database, defining and implementing sample entities, and developing basic CRUD (Create, Read, Update, Delete) operations.

Configuring Database Connection

To establish a connection to a PostgreSQL database, we need to configure the database connection settings in our NestJS application. We will use the @nestjs/typeorm package to interact with the database.

Step 1: Install Required Packages

First, we need to install the required packages using npm or yarn.

npm install @nestjs/typeorm typeorm pg

Step 2: Create Database Connection Module

Next, we need to create a database connection module that will handle the connection to the database.

// database.module.ts
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { User } from './user.entity';
import { Course } from './course.entity';

@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: 'postgres',
      url: 'localhost:5432',
      username: 'username',
      password: 'password',
      database: 'database',
      entities: [User, Course],
      synchronize: true,
    }),
  ],
})
export class DatabaseModule {}

In the above code, we are using the TypeOrmModule to configure the database connection. We are specifying the database type as postgres, the URL, username, password, and database name. We are also specifying the entities that will be used in the application.

Step 3: Create Entity Modules

Next, we need to create entity modules for the User and Course entities.

// user.entity.ts
import { Entity, Column, PrimaryGeneratedColumn } from 'typeorm';

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

  @Column()
  name: string;

  @Column()
  email: string;
}

// course.entity.ts
import { Entity, Column, PrimaryGeneratedColumn } from 'typeorm';

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

  @Column()
  name: string;

  @Column()
  description: string;
}

In the above code, we are defining the User and Course entities using the @Entity() decorator. We are specifying the columns for each entity using the @Column() decorator.

Defining and Implementing Sample Entities

Now that we have configured the database connection and defined the entities, we can implement the sample entities.

Step 1: Create Entity Service

First, we need to create an entity service that will handle the CRUD operations for the entities.

// user.service.ts
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { User } from './user.entity';

@Injectable()
export class UserService {
  constructor(
    @InjectRepository(User)
    private readonly userRepository: Repository<User>,
  ) {}

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

  async findOne(id: number): Promise<User> {
    return this.userRepository.findOne(id);
  }

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

  async update(id: number, user: User): Promise<User> {
    return this.userRepository.update(id, user);
  }

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

In the above code, we are creating a user service that will handle the CRUD operations for the User entity. We are using the @InjectRepository() decorator to inject the User repository into the service.

Step 2: Create Entity Controller

Next, we need to create an entity controller that will handle the HTTP requests for the entities.

// user.controller.ts
import { Controller, Get, Post, Put, Delete, Body, Param } from '@nestjs/common';
import { UserService } from './user.service';

@Controller('users')
export class UserController {
  constructor(private readonly userService: UserService) {}

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

  @Get(':id')
  async findOne(@Param('id') id: number): Promise<User> {
    return this.userService.findOne(id);
  }

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

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

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

In the above code, we are creating a user controller that will handle the HTTP requests for the User entity. We are using the @Controller() decorator to specify the controller and the @Get(), @Post(), @Put(), and @Delete() decorators to specify the HTTP methods.

Developing Basic CRUD Operations

Now that we have implemented the sample entities, we can develop basic CRUD operations for the entities.

Step 1: Implement Create Operation

First, we need to implement the create operation for the User entity.

// user.controller.ts
@Post()
async create(@Body() user: User): Promise<User> {
  return this.userService.create(user);
}

In the above code, we are implementing the create operation for the User entity. We are using the @Post() decorator to specify the HTTP method and the @Body() decorator to specify the request body.

Step 2: Implement Read Operation

Next, we need to implement the read operation for the User entity.

// user.controller.ts
@Get()
async findAll(): Promise<User[]> {
  return this.userService.findAll();
}

In the above code, we are implementing the read operation for the User entity. We are using the @Get() decorator to specify the HTTP method.

Step 3: Implement Update Operation

Next, we need to implement the update operation for the User entity.

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

In the above code, we are implementing the update operation for the User entity. We are using the @Put() decorator to specify the HTTP method and the @Param() decorator to specify the request parameter.

Step 4: Implement Delete Operation

Finally, we need to implement the delete operation for the User entity.

// user.controller.ts
@Delete(':id')
async delete(@Param('id') id: number): Promise<void> {
  return this.userService.delete(id);
}

In the above code, we are implementing the delete operation for the User entity. We are using the @Delete() decorator to specify the HTTP method and the @Param() decorator to specify the request parameter.

Conclusion

Introduction

In our previous article, we explored how to implement a database connection using TypeORM and NestJS. We covered the configuration of a connection to a PostgreSQL database, defining and implementing sample entities, and developing basic CRUD operations for these entities. In this article, we will answer some frequently asked questions (FAQs) related to implementing database connection with TypeORM and NestJS.

Q&A

Q: What is TypeORM and why do I need it?

A: TypeORM is a TypeScript-based Object-Relational Mapping (ORM) library that allows you to interact with databases using TypeScript classes. You need TypeORM to interact with your database in a type-safe and efficient way.

Q: What is NestJS and why do I need it?

A: NestJS is a framework for building efficient, scalable Node.js server-side applications. You need NestJS to build a robust and scalable application that can handle complex business logic and database interactions.

Q: How do I configure the database connection in NestJS?

A: To configure the database connection in NestJS, you need to create a database connection module that will handle the connection to the database. You can use the @nestjs/typeorm package to interact with the database.

Q: What are entities in TypeORM and how do I define them?

A: Entities in TypeORM are classes that represent tables in your database. You define entities using the @Entity() decorator and specify the columns for each entity using the @Column() decorator.

Q: How do I implement CRUD operations in NestJS?

A: To implement CRUD operations in NestJS, you need to create a service that will handle the CRUD operations for each entity. You can use the @InjectRepository() decorator to inject the repository for each entity into the service.

Q: What is the difference between `@InjectRepository()` and `@Repository()`?

A: @InjectRepository() is used to inject the repository for an entity into a service, while @Repository() is used to define a repository for an entity.

Q: How do I handle errors and exceptions in NestJS?

A: To handle errors and exceptions in NestJS, you can use the try-catch block to catch any errors that occur during the execution of your code. You can also use the @Catch() decorator to catch specific exceptions.

Q: What is the difference between `@Get()`, `@Post()`, `@Put()`, and `@Delete()`?

A: @Get() is used to handle GET requests, @Post() is used to handle POST requests, @Put() is used to handle PUT requests, and @Delete() is used to handle DELETE requests.

Q: How do I implement authentication and authorization in NestJS?

A: To implement authentication and authorization in NestJS, you can use the @nestjs/passport package to handle authentication and the @nestjs/jwt package to handle authorization.

Q: What is the difference between `@Injectable()` and `@Controller()`?

A: @Injectable() is used to define a service that can be injected into other services, while @Controller() is used to define a controller that handles HTTP requests.

Conclusion

In this article, we have answered some frequently asked questions related to implementing database connection with TypeORM and NestJS. We have covered topics such as configuring the database connection, defining and implementing entities, implementing CRUD operations, handling errors and exceptions, and implementing authentication and authorization. We hope that this article has been helpful in answering your questions and providing you with a better understanding of how to implement database connection with TypeORM and NestJS.