Explicación Detallada de los Archivos y Directorios Principales en el Directorio src de un Proyecto NestJS

  • 841Palabras
  • 4Minutos
  • 07 Jul, 2024

La estructura de directorios de un proyecto NestJS es clara y altamente escalable. En el desarrollo real, comprender y utilizar adecuadamente la función de cada archivo y directorio es crucial para construir proyectos eficientes y mantenibles. Este artículo explica en detalle la función de los principales archivos y directorios en el directorio src de un proyecto NestJS, y muestra cómo colaboran múltiples módulos a través de ejemplos prácticos.

app.module.ts

El archivo app.module.ts es el módulo raíz de la aplicación NestJS. Define la estructura principal y las dependencias de la aplicación. Todos los módulos, controladores y servicios se registran y gestionan a través del módulo raíz.

1
import { Module } from "@nestjs/common";
2
import { TypeOrmModule } from "@nestjs/typeorm";
3
import { ConfigModule } from "@nestjs/config";
4
import { UsersModule } from "./users/users.module";
5
import { ProductsModule } from "./products/products.module";
6


7
@Module({
8
  imports: [
9
    ConfigModule.forRoot(),
10
    TypeOrmModule.forRoot(),
11
    UsersModule,
12
    ProductsModule,
13
  ],
14
  controllers: [],
15
  providers: [],
16
})
17
export class AppModule {}

En el ejemplo anterior, AppModule importa UsersModule y ProductsModule, integrándolos en la aplicación.

main.ts

El archivo main.ts es el punto de entrada de la aplicación NestJS. Es responsable de iniciar la aplicación y lanzar el servidor HTTP de NestJS.

1
import { NestFactory } from "@nestjs/core";
2
import { AppModule } from "./app.module";
3


4
async function bootstrap() {
5
  const app = await NestFactory.create(AppModule);
6
  await app.listen(3000);
7
}
8
bootstrap();

En el ejemplo anterior, el archivo main.ts utiliza NestFactory para crear una aplicación NestJS basada en AppModule, y la hace escuchar en el puerto 3000.

controllers

Los controladores (Controllers) son clases en NestJS que manejan las solicitudes HTTP. Cada controlador define un conjunto de rutas que corresponden a diferentes caminos y métodos de solicitud.

1
import { Controller, Get, Post, Body, Param } from "@nestjs/common";
2
import { UsersService } from "./users.service";
3
import { CreateUserDto } from "./dto/create-user.dto";
4


5
@Controller("users")
6
export class UsersController {
7
  constructor(private readonly usersService: UsersService) {}
8


9
  @Get()
10
  findAll() {
11
    return this.usersService.findAll();
12
  }
13


14
  @Get(":id")
15
  findOne(@Param("id") id: string) {
16
    return this.usersService.findOne(+id);
17
  }
18


19
  @Post()
20
  create(@Body() createUserDto: CreateUserDto) {
21
    return this.usersService.create(createUserDto);
22
  }
23
}

En el ejemplo anterior, UsersController define tres rutas que manejan el camino /users: GET /users, GET /users/:id y POST /users.

services

Los servicios (Services) son clases en NestJS que manejan la lógica de negocios. Los servicios generalmente se inyectan en los controladores para manejar las solicitudes y devolver los datos.

1
import { Injectable } from "@nestjs/common";
2
import { User } from "./user.entity";
3
import { InjectRepository } from "@nestjs/typeorm";
4
import { Repository } from "typeorm";
5
import { CreateUserDto } from "./dto/create-user.dto";
6


7
@Injectable()
8
export class UsersService {
9
  constructor(
10
    @InjectRepository(User)
11
    private usersRepository: Repository<User>,
12
  ) {}
13


14
  findAll(): Promise<User[]> {
15
    return this.usersRepository.find();
16
  }
17


18
  findOne(id: number): Promise<User> {
19
    return this.usersRepository.findOneBy({ id });
20
  }
21


22
  create(createUserDto: CreateUserDto): Promise<User> {
23
    const user = this.usersRepository.create(createUserDto);
24
    return this.usersRepository.save(user);
25
  }
26
}

En el ejemplo anterior, UsersService utiliza TypeORM para manejar las operaciones CRUD de la entidad User, y proporciona los métodos findAll, findOne y create.

modules

Los módulos (Modules) son clases en NestJS que organizan la estructura de la aplicación. Cada módulo puede contener múltiples controladores y servicios, y puede importar otros módulos.

1
import { Module } from "@nestjs/common";
2
import { TypeOrmModule } from "@nestjs/typeorm";
3
import { UsersController } from "./users.controller";
4
import { UsersService } from "./users.service";
5
import { User } from "./user.entity";
6


7
@Module({
8
  imports: [TypeOrmModule.forFeature([User])],
9
  controllers: [UsersController],
10
  providers: [UsersService],
11
})
12
export class UsersModule {}

En el ejemplo anterior, UsersModule importa TypeOrmModule y registra la entidad User, además de definir UsersController y UsersService.

Colaboración entre Múltiples Módulos

En un proyecto real, múltiples módulos necesitan colaborar. A continuación, mostramos cómo usar el servicio de un módulo en otro módulo, tomando como ejemplo UsersModule y ProductsModule.

Primero, crea un ProductsModule:

Terminal window
1
nest generate module products
2
nest generate controller products
3
nest generate service products

Define la entidad Product:

1
import { Entity, Column, PrimaryGeneratedColumn } from "typeorm";
2


3
@Entity()
4
export class Product {
5
  @PrimaryGeneratedColumn()
6
  id: number;
7


8
  @Column()
9
  name: string;
10


11
  @Column()
12
  price: number;
13
}

Configura ProductsModule:

1
import { Module } from "@nestjs/common";
2
import { TypeOrmModule } from "@nestjs/typeorm";
3
import { ProductsController } from "./products.controller";
4
import { ProductsService } from "./products.service";
5
import { Product } from "./product.entity";
6
import { UsersModule } from "../users/users.module"; // Importar UsersModule
7


8
@Module({
9
  imports: [TypeOrmModule.forFeature([Product]), UsersModule], // Importar UsersModule
10
  controllers: [ProductsController],
11
  providers: [ProductsService],
12
})
13
export class ProductsModule {}

Usa UsersService en ProductsService:

1
import { Injectable } from "@nestjs/common";
2
import { InjectRepository } from "@nestjs/typeorm";
3
import { Repository } from "typeorm";
4
import { Product } from "./product.entity";
5
import { UsersService } from "../users/users.service"; // Importar UsersService
6


7
@Injectable()
8
export class ProductsService {
9
  constructor(
10
    @InjectRepository(Product)
11
    private productsRepository: Repository<Product>,
12
    private usersService: UsersService, // Inyectar UsersService
13
  ) {}
14


15
  findAll(): Promise<Product[]> {
16
    return this.productsRepository.find();
17
  }
18


19
  findOne(id: number): Promise<Product> {
20
    return this.productsRepository.findOneBy({ id });
21
  }
22


23
  async create(name: string, price: number): Promise<Product> {
24
    const user = await this.usersService.findOne(1); // Usar UsersService
25
    if (user) {
26
      const product = this.productsRepository.create({ name, price });
27
      return this.productsRepository.save(product);
28
    }
29
    return null;
30
  }
31
}

En el ejemplo anterior, ProductsService inyecta UsersService a través del constructor, y usa el método de UsersService en el método create.

Conclusión

Este artículo detalla la función de los principales archivos y directorios en el directorio src de un proyecto NestJS, incluyendo app.module.ts, main.ts, controllers, services y modules, y muestra cómo colaboran múltiples módulos a través de ejemplos prácticos. Al organizar y usar adecuadamente estos archivos y directorios, se puede construir un proyecto NestJS eficiente y mantenible.

Artículos similares

Cómo Diferenciar el Entorno de Desarrollo y el Entorno de Producción y su Configuración (NestJS + MySQL + TypeScript)

Cómo Diferenciar el Entorno de Desarrollo y el Entorno de Producción y su Configuración (NestJS + MySQL + TypeScript)

Explicación Detallada del Controlador de NestJS: Manejo de Diferentes Métodos de Solicitud HTTP y Parámetros de Ruta

Explicación Detallada del Controlador de NestJS: Manejo de Diferentes Métodos de Solicitud HTTP y Parámetros de Ruta