Node.js

Como criar um projeto em Nest.js

Neste tutorial, você verá:

✔️ Criar um projeto usando o Nest.js;

📌 Simplifique seu processo de deploy com o nosso painel ICP!

Nesse tutorial vamos aprenda a desenvolver, configurar Nest.js. Tudo explicado de forma simples e prática!

📌 Passo 1: Estrutura básica do projeto Nest.js

Ao iniciar um projeto Nest.js, a estrutura de pastas e arquivos é organizada da seguinte maneira:

hello-world/
├── src/
│   ├── app.controller.ts
│   ├── app.module.ts
│   ├── app.service.ts
│   └── main.ts
├── package.json
├── tsconfig.json
└── ...

src/: Pasta principal que contém o código-fonte do aplicativo.
- app.controller.ts: Define como as requisições HTTP são tratadas.
- app.module.ts: Módulo raiz que organiza os componentes do aplicativo.
- app.service.ts: Contém a lógica de negócios e serviços utilizados pelos controladores.
- main.ts: Arquivo de entrada que inicia a aplicação.
package.json: Lista as dependências e scripts do projeto.
tsconfig.json: Configurações do compilador TypeScript.

📌 Passo 2: Editando o arquivo package.json

O arquivo package.json gerencia as dependências e scripts do projeto. Um exemplo de configuração é:

{
  "name": "integrator-host",
  "version": "1.0.0",
  "description": "Exemplo de uso do NestJS - Integrator Host",
  "main": "dist/main.js",
  "scripts": {
    "install-and-start": "npm install && npm run start",
    "start": "nest start",
    "start:dev": "nest start --watch",
    "build": "tsc",
    "lint": "eslint . --ext .ts"
  },
  "dependencies": {
    "@nestjs/common": "^10.0.0",
    "@nestjs/core": "^10.0.0",
    "@nestjs/platform-express": "^10.0.0",
    "reflect-metadata": "^0.1.13",
    "rxjs": "^7.0.0"
  },
  "devDependencies": {
    "@nestjs/cli": "^10.0.0",
    "@nestjs/schematics": "^10.0.0",
    "@types/node": "^20.0.0",
    "eslint": "^8.0.0",
    "eslint-config-prettier": "^9.0.0",
    "typescript": "^5.0.0"
  }
}

scripts: Comandos para facilitar tarefas comuns, como iniciar o servidor (start) e compilar o código (build).
dependencies: Bibliotecas necessárias para o funcionamento do aplicativo.
devDependencies: Ferramentas utilizadas durante o desenvolvimento, como o TypeScript e o ESLint.

📌 Passo 3: Configurando o tsconfig.json

{
  "compilerOptions": {
    "module": "commonjs",
    "target": "es2017",
    "moduleResolution": "node",
    "strict": true,
    "skipLibCheck": true,
    "experimentalDecorators": true,
    "emitDecoratorMetadata": true,
    "outDir": "./dist",
    "rootDir": "./src"
  },
  "include": ["src/**/*"]
}

compilerOptions: Configurações que determinam como o TypeScript compila o código.

module: Especifica o sistema de módulos a ser utilizado.
target: Define a versão do JavaScript que o código será compilado.
outDir: Diretório onde o código compilado será salvo.
rootDir: Diretório raiz do código-fonte.

📌 Passo 4: Criando o controlador /src/app.controller.ts

O controlador lida com as requisições HTTP e retorna respostas adequadas:

import { Controller, Get } from '@nestjs/common';

@Controller()
export class AppController {
  @Get()
  getHello(): string {
    console.log('Endpoint "/" foi acessado.');
    return `
      <html>
        <head>
          <title>Integrator Host - Home</title>
        </head>
        <body>
          <h1>Olá, Mundo!</h1>
          <p>Bem-vindo à primeira página feita em Nest.js</p>
          <a href="/rota2">Ir para a segunda página</a>
        </body>
      </html>
    `;
  }

  @Get('rota2')
  getSecondRoute(): string {
    console.log('Endpoint "/rota2" foi acessado.');
    return `
      <html>
        <head>
          <title>Integrator Host - Página 2</title>
        </head>
        <body>
          <h1>Esta é a segunda rota!</h1>
          <p>Você está na segunda página.</p>
          <a href="/">Voltar para a primeira página</a>
        </body>
      </html>
    `;
  }
}

@Controller(): Decorator que indica que a classe lida com requisições HTTP.
@Get(): Decorator que define um endpoint para requisições GET.
getHello(): Método que retorna uma página HTML simples quando a rota raiz ("/") é acessada.
getSecondRoute(): Método que retorna outra página HTML quando a rota "/rota2" é acessada.

📌 Passo 5: Definindo o módulo principal /src/app.module.ts

O módulo principal organiza os componentes do aplicativo e informa ao NestJS quais partes do código serão utilizadas.

import { Module } from '@nestjs/common';
import { AppController } from './app.controller';

@Module({
  imports: [],
  controllers: [AppController],
  providers: [],
})
export class AppModule {}

@Module(): Indica que essa classe é um módulo dentro do NestJS.
controllers: [AppController]: Define quais controladores (como AppController) serão utilizados no projeto.
export class AppModule {}: Exporta a classe AppModule, que será usada para configurar a aplicação.

Esse módulo é o "cérebro" do aplicativo, dizendo ao NestJS quais partes devem ser carregadas.

📌 Passo 6: Criando o arquivo de inicialização /src/main.ts

O arquivo de inicialização (main.ts) é responsável por iniciar o servidor do NestJS.

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(3025);
  console.log('Application is running on http://localhost:3025');
}
bootstrap();

NestFactory.create(AppModule): Cria a aplicação a partir do AppModule.
await app.listen(3000);: Faz a aplicação rodar na porta 3000, tornando-a acessível pelo navegador em http://localhost:3000.

Agora, se você executar npm run start, o servidor estará rodando e pronto para receber requisições.

📌 Passo 7: Rodar a aplicação.

Instalar todas as dependências: