NestJS Basics

npm i -g @nestjs/cli@11
nest new my-api --strict
cd my-api
npm pkg set type=module

// users.module.ts
import { Module } from "@nestjs/common";
import { UsersController } from "./users.controller.js";
import { UsersService } from "./users.service.js";
 
@Module({
  controllers: [UsersController],
  providers: [UsersService],
})
export class UsersModule {}

// users.service.ts
import { Injectable } from "@nestjs/common";
 
@Injectable()
export class UsersService {
  findAll() {
    return [{ id: 1, name: "Ada Lovelace" }];
  }
}

// users.controller.ts
import { Controller, Get } from "@nestjs/common";
import { UsersService } from "./users.service.js";
 
@Controller("users")
export class UsersController {
  constructor(private readonly usersService: UsersService) {}
 
  @Get()
  findAll() {
    return this.usersService.findAll();
  }
}

import { Controller, Get, Post, Body, Param } from "@nestjs/common";
 
@Controller("users")
export class UsersController {
  @Get(":id")
  findOne(@Param("id") id: string) {
    return { id, name: "Ada" };
  }
 
  @Post()
  create(@Body() body: { name: string; email: string }) {
    return { id: "1", ...body };
  }
}

// app.module.ts
import { Module } from "@nestjs/common";
import { UsersModule } from "./users/users.module.js";
 
@Module({
  imports: [UsersModule],
})
export class AppModule {}

// main.ts
import { NestFactory } from "@nestjs/core";
import { AppModule } from "./app.module.js";
 
async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(process.env.PORT ?? 3000);
}
bootstrap();

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.setGlobalPrefix("api/v1");
  await app.listen(3000);
}

import { ValidationPipe } from "@nestjs/common";
 
async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.useGlobalPipes(new ValidationPipe({ whitelist: true, transform: true }));
  await app.listen(3000);
}

import { IsEmail, IsString, MinLength } from "class-validator";
 
export class CreateUserDto {
  @IsString()
  @MinLength(1)
  name!: string;
 
  @IsEmail()
  email!: string;
}

import { ExceptionFilter, Catch, ArgumentsHost, HttpException } from "@nestjs/common";
 
@Catch(HttpException)
export class HttpExceptionFilter implements ExceptionFilter {
  catch(exception: HttpException, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const response = ctx.getResponse();
    const status = exception.getStatus();
    response.status(status).json(exception.getResponse());
  }
}

import { Module } from "@nestjs/common";
import { ConfigModule } from "@nestjs/config";
 
@Module({
  imports: [ConfigModule.forRoot({ isGlobal: true })],
})
export class AppModule {}

import { Injectable } from "@nestjs/common";
import { ConfigService } from "@nestjs/config";
 
@Injectable()
export class AppService {
  constructor(private config: ConfigService) {}
 
  getPort() {
    return this.config.get<number>("PORT", 3000);
  }
}

import { NestFactory } from "@nestjs/core";
import { FastifyAdapter, NestFastifyApplication } from "@nestjs/platform-fastify";
import { AppModule } from "./app.module.js";
 
async function bootstrap() {
  const app = await NestFactory.create<NestFastifyApplication>(
    AppModule,
    new FastifyAdapter({ logger: true })
  );
  await app.listen({ port: 3000, host: "0.0.0.0" });
}
bootstrap();

@Module({
  providers: [UsersService],
  exports: [UsersService],
})
export class UsersModule {}
 
@Module({
  imports: [UsersModule],
  controllers: [OrdersController],
})
export class OrdersModule {}
// OrdersController can inject UsersService

import { Injectable, OnModuleInit, OnModuleDestroy } from "@nestjs/common";
 
@Injectable()
export class DatabaseService implements OnModuleInit, OnModuleDestroy {
  async onModuleInit() {
    console.log("Connecting to database...");
  }
 
  async onModuleDestroy() {
    console.log("Closing database connections...");
  }
}