🛒 E-Commerce API - Projeto Educacional NestJS

Uma API simples e educacional para aprender NestJS construindo uma API inspirada no Mercado Livre.

🚀 Quick Start

Requisitos

Node.js v18+
npm ou yarn

Instalação e Execução

# 1. Instalar dependências
npm install

# 2. Rodar em modo desenvolvimento
npm run start:dev

# 3. A API estará disponível em http://localhost:3000

Testar a API

# GET http://localhost:3000
curl http://localhost:3000

Resposta:

{
  "message": "API E-commerce rodando! 🚀"
}

📐 Entendendo a Arquitetura Mínima

O que temos agora?

Atualmente, temos a estrutura mínima de uma API NestJS:

src/
├── main.ts              ← Arquivo de entrada (bootstrap da aplicação)
├── app.module.ts        ← Módulo raiz (agrupa tudo)
├── app.controller.ts    ← Controlador (recebe requisições HTTP)
└── app.service.ts       ← Serviço (contém a lógica de negócio)

Fluxo de uma requisição HTTP

┌─────────────────────────────────────────────────────────┐
│                  REQUISIÇÃO HTTP                        │
│                  GET /                                  │
└──────────────────────┬──────────────────────────────────┘
                       │
                       ▼
        ┌──────────────────────────────────┐
        │   main.ts                        │
        │   (Cria a aplicação NestJS)      │
        │   (Listen na porta 3000)         │
        └──────────────────┬───────────────┘
                           │
                           ▼
        ┌──────────────────────────────────┐
        │   app.module.ts                  │
        │   (Agrupa Controllers e          │
        │    Providers/Services)           │
        └──────────────────┬───────────────┘
                           │
                           ▼
        ┌──────────────────────────────────┐
        │   app.controller.ts              │
        │   (Recebe: GET /                 │
        │    Injeta: AppService            │
        │    Chama: getHello())            │
        └──────────────────┬───────────────┘
                           │
                           ▼
        ┌──────────────────────────────────┐
        │   app.service.ts                 │
        │   (Executa a lógica              │
        │    Retorna: {message: "..."})    │
        └──────────────────┬───────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────┐
│                 RESPOSTA JSON                           │
│           { "message": "API rodando! 🚀" }             │
└─────────────────────────────────────────────────────────┘

📚 As 4 Classes Mínimas Explicadas

1️⃣ main.ts - O Bootstrap da Aplicação

O que faz: Inicializa a aplicação NestJS e abre um servidor HTTP.

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

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  const port = process.env.PORT ?? 3000;
  await app.listen(port);
  console.log(`🚀 API rodando em http://localhost:${port}`);
}
bootstrap();

Explicação:

NestFactory.create() → Cria a aplicação a partir do módulo raiz
app.listen(port) → Abre um servidor HTTP na porta especificada
É o primeiro arquivo a executar quando você roda npm run start:dev

2️⃣ app.module.ts - O Módulo Raiz

O que faz: Define quais Controllers e Providers fazem parte da aplicação.

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

@Module({
  imports: [],           // Módulos que este módulo depende
  controllers: [AppController],  // Controladores HTTP
  providers: [AppService],       // Serviços (lógica de negócio)
})
export class AppModule {}

Explicação:

@Module() → Decorador que marca a classe como um módulo
controllers → Lista os Controllers (rotas HTTP)
providers → Lista os Services (lógica de negócio)
imports → Para adicionar outros módulos (Auth, Produtos, etc)

3️⃣ app.controller.ts - O Controlador HTTP

O que faz: Define as rotas HTTP e delega para o Service.

import { Controller, Get } from '@nestjs/common';
import { AppService } from './app.service';

@Controller()  // Define a base da rota (vazio = raiz /)
export class AppController {
  constructor(private readonly appService: AppService) {}
  // ↑ Injeta o Service automaticamente (Dependency Injection)

  @Get()  // Define um endpoint GET na rota /
  getHello() {
    return this.appService.getHello();
    // ↑ Chama o método do Service
  }
}

Explicação:

@Controller() → Marca a classe como um controlador
@Get() → Define um endpoint GET (existem também @Post, @Put, @Delete)
constructor(private readonly appService: AppService) → Injeção de dependência (NestJS fornece automaticamente)
O Controller NÃO tem lógica, apenas recebe requisições e chama o Service

4️⃣ app.service.ts - O Serviço (Lógica de Negócio)

O que faz: Contém a lógica de negócio da aplicação.

import { Injectable } from '@nestjs/common';

@Injectable()  // Marca como um provider que pode ser injetado
export class AppService {
  getHello(): { message: string } {
    return { message: 'API E-commerce rodando! 🚀' };
  }
}

Explicação:

@Injectable() → Marca a classe como um provider (pode ser injetado em Controllers/Services)
O Service contém TODA a lógica de negócio
Múltiplos Controllers podem usar o mesmo Service

🎯 O Padrão MVC no NestJS

Requisição HTTP
      ↓
   Controller (recebe e valida)
      ↓
   Service (processa a lógica)
      ↓
   Banco de dados ou outro recurso
      ↓
   Service retorna resultado
      ↓
   Controller retorna resposta
      ↓
Resposta HTTP

📈 Plano de Evolução da API

Fase 1: Produtos (2-3 aulas)

Aprender os conceitos básicos: Controller, Service, Module, DTO

nova estrutura:
src/
├── main.ts
├── app.module.ts
├── app.controller.ts
├── app.service.ts
└── products/                    ← NOVO MÓDULO
    ├── products.module.ts
    ├── products.controller.ts
    ├── products.service.ts
    ├── entities/
    │   └── product.entity.ts     ← Modelo de dados
    └── dto/
        └── create-product.dto.ts ← Validação de entrada

Endpoints:

GET /products - Listar todos
GET /products/:id - Buscar um
POST /products - Criar novo
PUT /products/:id - Atualizar
DELETE /products/:id - Deletar

Fase 2: Autenticação (2-3 aulas)

Aprender: Guards, JWT, Pipes, Decorators

nova estrutura:
src/
├── ...
├── auth/                        ← NOVO MÓDULO
│   ├── auth.module.ts
│   ├── auth.controller.ts
│   ├── auth.service.ts
│   ├── entities/
│   │   └── user.entity.ts
│   └── dto/
│       ├── register.dto.ts
│       └── login.dto.ts
└── common/                      ← Código compartilhado
    ├── guards/
    │   └── jwt-auth.guard.ts    ← Protege rotas
    ├── decorators/
    │   └── current-user.decorator.ts
    └── pipes/
        └── validation.pipe.ts

Endpoints:

POST /auth/register - Registrar
POST /auth/login - Login
POST /auth/logout - Logout

Novo conceito: Apenas rotas autenticadas funcionam

Fase 3: Carrinho de Compras (2 aulas)

Aprender: Injeção de dependências entre módulos

nova estrutura:
src/
├── ...
├── cart/                        ← NOVO MÓDULO
│   ├── cart.module.ts
│   ├── cart.controller.ts
│   ├── cart.service.ts
│   ├── entities/
│   │   └── cart-item.entity.ts
│   └── dto/
│       └── add-to-cart.dto.ts
├── products/
│   └── ...
└── auth/
    └── ...

Endpoints:

GET /cart - Ver carrinho (autenticado)
POST /cart - Adicionar produto (autenticado)
DELETE /cart/:id - Remover (autenticado)

Novo conceito: O CartService usa ProductsService (módulos falando entre si)

Fase 4: Pedidos (2 aulas)

Aprender: Lógica complexa, transações

nova estrutura:
src/
├── ...
└── orders/                      ← NOVO MÓDULO
    ├── orders.module.ts
    ├── orders.controller.ts
    ├── orders.service.ts
    ├── entities/
    │   └── order.entity.ts
    └── dto/
        └── create-order.dto.ts

Endpoints:

POST /orders - Criar pedido do carrinho (autenticado)
GET /orders - Listar meus pedidos (autenticado)
GET /orders/:id - Ver detalhes (autenticado)
PUT /orders/:id/cancel - Cancelar (autenticado)

Fase 5: Adicionais (extras)

Filters (tratamento de erros)
Interceptors (logs, transformações)
Middleware (CORS, logging global)

💡 Resumo: Por que essa estrutura?

Conceito	Por que?
Module	Agrupa funcionalidades (produtos, auth, carrinho)
Controller	Define rotas HTTP (GET, POST, PUT, DELETE)
Service	Contém a lógica (não mistura com HTTP)
DTO	Valida dados que vêm da requisição
Entity	Representa um objeto do banco de dados
Guard	Protege rotas (autenticação, autorização)
Decorator	Adiciona metadados (JWT, usuário autenticado)
Pipe	Transforma e valida dados antes de chegar ao Controller
Interceptor	Processa requisições/respostas (logs, transformações)
Filter	Trata exceções e erros

Name		Name	Last commit message	Last commit date
.claude		.claude
prisma		prisma
src		src
test		test
.env.example		.env.example
.gitignore		.gitignore
.prettierrc		.prettierrc
ARQUITETURA_DDD.md		ARQUITETURA_DDD.md
CLEAN_ARCHITECTURE_DESIGN.md		CLEAN_ARCHITECTURE_DESIGN.md
README.md		README.md
eslint.config.mjs		eslint.config.mjs
nest-cli.json		nest-cli.json
package-lock.json		package-lock.json
package.json		package.json
setup-database.sql		setup-database.sql
tsconfig.build.json		tsconfig.build.json
tsconfig.json		tsconfig.json

Navigation Menu

Repository files navigation

🛒 E-Commerce API - Projeto Educacional NestJS

🚀 Quick Start

Requisitos

Instalação e Execução

Testar a API

📐 Entendendo a Arquitetura Mínima

O que temos agora?

Fluxo de uma requisição HTTP

📚 As 4 Classes Mínimas Explicadas

1️⃣ main.ts - O Bootstrap da Aplicação

2️⃣ app.module.ts - O Módulo Raiz

3️⃣ app.controller.ts - O Controlador HTTP

4️⃣ app.service.ts - O Serviço (Lógica de Negócio)

🎯 O Padrão MVC no NestJS

📈 Plano de Evolução da API

Fase 1: Produtos (2-3 aulas)

Fase 2: Autenticação (2-3 aulas)

Fase 3: Carrinho de Compras (2 aulas)

Fase 4: Pedidos (2 aulas)

Fase 5: Adicionais (extras)

💡 Resumo: Por que essa estrutura?

🎓 Como Estudar

📖 Referências

📄 License

About

Releases

Packages

Contributors

Languages

Latest commit

History

Folders and files

Repository files navigation

🛒 E-Commerce API - Projeto Educacional NestJS

🚀 Quick Start

Requisitos

Instalação e Execução

Testar a API

📐 Entendendo a Arquitetura Mínima

O que temos agora?

Fluxo de uma requisição HTTP

📚 As 4 Classes Mínimas Explicadas

1️⃣ main.ts - O Bootstrap da Aplicação

2️⃣ app.module.ts - O Módulo Raiz

3️⃣ app.controller.ts - O Controlador HTTP

4️⃣ app.service.ts - O Serviço (Lógica de Negócio)

🎯 O Padrão MVC no NestJS

📈 Plano de Evolução da API

Fase 1: Produtos (2-3 aulas)

Fase 2: Autenticação (2-3 aulas)

Fase 3: Carrinho de Compras (2 aulas)

Fase 4: Pedidos (2 aulas)

Fase 5: Adicionais (extras)

💡 Resumo: Por que essa estrutura?

🎓 Como Estudar

📖 Referências

📄 License

About

Resources

Stars

Watchers

Forks

Releases

Packages

Contributors

Languages