TypeORM supports the repository design pattern, so each entity has its own repository. In NestJS, this adherence to the repository pattern facilitates cleaner, more modular code by separating the database logic from business logic, aligning with software engineering best practices.

These repositories can be obtained from the database data source. In a NestJS application, you usually inject these repositories into your services or controllers via Dependency Injection, enabling direct interaction with the database through methods like 

@Module({
  imports: [TypeOrmModule.forFeature([Song])],
  controllers: [SongsController],
  providers: [SongsService],
})

To use the SongRepository we need to import the TypeORM module into the Songs module. This module uses the 

 method to define which repositories are registered in the current scope. With that in place, we can inject the 

import { Song } from "./song.entity";
import { InjectRepository } from "@nestjs/typeorm";
export class SongsService {
  constructor(
    @InjectRepository(Song)
    private songRepository: Repository<Song>
  ) {}
}

 methods to create, delete, update, and fetch records from the Songs table. In a NestJS application, this specialized repository is responsible for handling all operations related to the Songs entity, abstracting the database interactions and thus adhering to the repository best practice.  

Now, you should implement the create song method. This time, there is no need to add a record in the local db array. Save the new song in the database by using the 

async create(songDTO: CreateSongDto): Promise<Song> {
  const song = new Song();
  song.title = songDTO.title;
  song.artists = songDTO.artists;
  song.duration = songDTO.duration;
  song.lyrics = songDTO.lyrics;
  song.releasedDate = songDTO.releasedDate;


return await this.songRepository.save(song);
  // method 
}

Instantiate a new song instance from the Song Entity. Set the fields of the songs table using the DTO object, and finally, return a promise containing the song object from the create method.

A database promise is essential for handling asynchronous operations when interacting with a database. In a web application, tasks like querying, updating, or deleting records are not instantaneous and can take an undefined amount of time to complete. Utilizing promises allows your application to continue executing other tasks while waiting for the database operation to resolve, thereby improving performance and user experience.

In the context of NestJS and TypeORM, methods like save(), find(), or delete() often return promises. By defining a return type like Promise<Song[]> in your service or controller methods, you make it explicit that the function is asynchronous and will return data at a future point in time. This is particularly beneficial for type-checking and for setting the expectations for the developers who will consume these methods.

 method to save the record in a database table. You have to provide the instance of the entity which entity record you want to save

// songs.controller.ts
@Post()

create(@Body() createSongDTO: CreateSongDto): Promise<Song> {
  return this.songsService.create(createSongDTO);
}

Add the return type for the create method, which is a promise containing the Song entity.

---
title: Create and Fetch Records from the Database
privateVideoUrl: https://fullstack.wistia.com/medias/s9938ij9qz
isPublicLesson: true
---

### Repository Pattern

TypeORM supports the repository design pattern, so each entity has its own repository. In NestJS, this adherence to the repository pattern facilitates cleaner, more modular code by separating the database logic from business logic, aligning with software engineering best practices.

These repositories can be obtained from the database data source. In a NestJS application, you usually inject these repositories into your services or controllers via Dependency Injection, enabling direct interaction with the database through methods like `find`, `save`, or `delete`.

```ts
@Module({
  imports: [TypeOrmModule.forFeature([Song])],
  controllers: [SongsController],
  providers: [SongsService],
})
```

To use the SongRepository we need to import the TypeORM module into the Songs module. This module uses the `forFeature()` method to define which repositories are registered in the current scope. With that in place, we can inject the `SongRepository` into the SongService using the `@InjectRepository()` decorator:

```ts
import { Song } from "./song.entity";
import { InjectRepository } from "@nestjs/typeorm";
export class SongsService {
  constructor(
    @InjectRepository(Song)
    private songRepository: Repository<Song>
  ) {}
}
```

`SongRepository` provides `CRUD` methods to create, delete, update, and fetch records from the Songs table. In a NestJS application, this specialized repository is responsible for handling all operations related to the Songs entity, abstracting the database interactions and thus adhering to the repository best practice.  

### Create Record

Now, you should implement the create song method. This time, there is no need to add a record in the local db array. Save the new song in the database by using the `songRepository.save()` method

```ts
async create(songDTO: CreateSongDto): Promise<Song> {
  const song = new Song();
  song.title = songDTO.title;
  song.artists = songDTO.artists;
  song.duration = songDTO.duration;
  song.lyrics = songDTO.lyrics;
  song.releasedDate = songDTO.releasedDate;


return await this.songRepository.save(song);
  // method 
}
```

Instantiate a new song instance from the Song Entity. Set the fields of the songs table using the DTO object, and finally, return a promise containing the song object from the create method.

A database promise is essential for handling asynchronous operations when interacting with a database. In a web application, tasks like querying, updating, or deleting records are not instantaneous and can take an undefined amount of time to complete. Utilizing promises allows your application to continue executing other tasks while waiting for the database operation to resolve, thereby improving performance and user experience.

In the context of NestJS and TypeORM, methods like save(), find(), or delete() often return promises. By defining a return type like Promise&lt;Song\[]> in your service or controller methods, you make it explicit that the function is asynchronous and will return data at a future point in time. This is particularly beneficial for type-checking and for setting the expectations for the developers who will consume these methods.

Haider Malik

Create and Fetch Records from the Database

Type orem sports repository pattern for each entity type orem provides

And this repository has CRUD features like create, create record, update record

First of all, you have to register the type orem module as a feature into the

Like these entities I would like to use inside the songs module.

And it will provide the repository, songs repository here.

Then you can inject the songs repository.

To use songs repository, you need to import the type orem module into songs

This module uses the fourth feature method to define which repositories are

That's why we use the we have imported or added the song entity.

Now we can inject the songs repository into the songs service.

Just like we did it as a dependency injection.

Please inject the songs repository and the type of the entity which is song.

And you can import repository from NestGest, type orem package.

Now I told you songs repository provides script method to create, delete,

Create delete, fetch records from the songs table.

Let's implement this create song method this time.

We don't need to add a record in the local DB.

You're going to save the new song by using the song repository dot safe method.

Let's implement here in the songs module.

We have to import type orem module as a feature.

I would like to use this entity into the songs model in songs module.

Now you are able to inject songs repository into the songs service.

So I want you to inject these songs repository.

And I can provide the song type which is entity.

So song repository provides the safe method just like you learned here.

It provides the safe method for first of all, we have to create a new song.

And it should return a promise with song.

I just created the instance from a song class.

I got the artist from DTO duration lyrics and release date from the DTO.

And I would like to call this safe method and provide a newly created song and

Get rid of the songs array, I don't want to use it.

We also need to remove everything from here.

Make sure you have called, yeah, it should use the update expression here.

the controller, let's look at issue here, it should promise and the song.

And we have to provide the entity which is song.

Test without async by default it should return the promise.

This is the Linux duration and the release date.

It's easy to implement the point all you need to do.

Let's provide the return type, promise with song array.

In the controller, songs controller, you can also add promise

Now we need to implement the point one, find by ID.

You can create a new method inside the song service and it is taking the ID as

You can use song repository.point1 method.

In the controller, we need to parse the ID as an integer and return the song in

Let me open the songs controller, we already did it.

Let's test it out by sending the request on the base on ID.

If I try to fetch the second record, I don't have any record.

I'm going to create a new method inside the song service.

It's just returning nothing or you can say delete result.

Learn

The newline Guide to Building Your First GraphQL Server with Node and TypeScript

Teach

Amelia Wattenberger

Author of Fullstack D3

Community

Masterclasses

Tutorials

Fullstack React with TypeScript