How to get a repository or the current TypeORM instance of a NestFastifyApplication object?

When working with the NestJS framework alongside Fastify and TypeORM, accessing the repository or current TypeORM instance associated with the NestFastifyApplication object is a common and essential task. The following outlines the detailed steps and explanations for performing this operation.

Step 1: Inject the EntityManager or specific Repository of TypeORM

First, confirm that your NestJS module has correctly imported TypeOrmModule. This is achieved by utilizing TypeOrmModule.forRoot() or TypeOrmModule.forFeature() within your module file (typically app.module.ts). For example:

typescript
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { User } from './user.entity';

@Module({
  imports: [
    TypeOrmModule.forRoot({
      // Database connection configuration
    }),
    TypeOrmModule.forFeature([User])
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

Step 2: Inject the Repository into your service or controller

In the service or controller where database access is required, inject the corresponding Repository via the constructor. For instance, to use the User Repository in your service:

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

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

Step 3: Access the Repository through HTTP request handlers

Once the Repository is available within your service, leverage it in the HTTP request handlers of your controller for database operations. For example:

typescript
import { Controller, Get } from '@nestjs/common';
import { UserService } from './user.service';
import { User } from './user.entity';

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

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

Example: Accessing the TypeORM EntityManager

For more flexible database operations, inject the EntityManager instead of a specific Repository. This can be done similarly:

typescript
import { Injectable } from '@nestjs/common';
import { EntityManager } from 'typeorm';

@Injectable()
export class SomeService {
  constructor(private entityManager: EntityManager) {}

  async someOperation(): Promise<any> {
    // Perform operations using the entityManager
    return this.entityManager.query('SELECT * FROM some_table');
  }
}

By following these methods, you can effectively manage and utilize the TypeORM instance for database operations when working with NestFastifyApplication. This not only maintains structured and modular code but also enables you to leverage TypeORM's powerful features, such as transaction management and entity relationships.