NestJS Complete Guide — Enterprise Node.js

npm install -g @nestjs/cli
nest new my-app
cd my-app
npm run start:dev

import { Controller, Get, Post, Body, Param } from "@nestjs/common";
import { UserService } from "./user.service";

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

  @Get()
  findAll() {
    return this.userService.findAll();
  }

  @Get(":id")
  findOne(@Param("id") id: string) {
    return this.userService.findOne(parseInt(id));
  }

  @Post()
  create(@Body() createUserDto: CreateUserDto) {
    return this.userService.create(createUserDto);
  }
}

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

@Injectable()
export class UserService {
  private users = [
    { id: 1, name: "Alice", email: "alice@example.com" },
  ];

  findAll() {
    return this.users;
  }

  findOne(id: number) {
    return this.users.find((user) => user.id === id);
  }

  create(createUserDto: CreateUserDto) {
    const user = { id: 2, ...createUserDto };
    this.users.push(user);
    return user;
  }
}

import { Module } from "@nestjs/common";
import { UserService } from "./user.service";
import { UserController } from "./user.controller";

@Module({
  imports: [],
  controllers: [UserController],
  providers: [UserService],
  exports: [UserService], // Export for other modules
})
export class UserModule {}

// app.module.ts
import { Module } from "@nestjs/common";
import { UserModule } from "./user/user.module";

@Module({
  imports: [UserModule],
})
export class AppModule {}

interface Logger {
  log(message: string): void;
}

@Injectable()
class ConsoleLogger implements Logger {
  log(message: string): void {
    console.log(message);
  }
}

@Module({
  providers: [
    {
      provide: "Logger",
      useClass: ConsoleLogger,
    },
  ],
})
export class AppModule {}

@Injectable()
export class UserService {
  constructor(@Inject("Logger") private logger: Logger) {}

  findAll() {
    this.logger.log("Finding all users");
    return [];
  }
}

import { Injectable, CanActivate, ExecutionContext } from "@nestjs/common";

@Injectable()
export class AuthGuard implements CanActivate {
  canActivate(context: ExecutionContext): boolean {
    const request = context.switchToHttp().getRequest();
    return !!request.headers.authorization;
  }
}

@Controller("admin")
@UseGuards(AuthGuard)
export class AdminController {
  @Get()
  getAdminData() {
    return { admin: true };
  }
}

import { Injectable, NestMiddleware } from "@nestjs/common";
import { Request, Response, NextFunction } from "express";

@Injectable()
export class LoggerMiddleware implements NestMiddleware {
  use(req: Request, res: Response, next: NextFunction) {
    console.log(`${req.method} ${req.path}`);
    next();
  }
}

@Module({
  imports: [UserModule],
})
export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer
      .apply(LoggerMiddleware)
      .forRoutes(
        { path: "users", method: RequestMethod.GET },
        { path: "users/:id", method: RequestMethod.GET }
      );
  }
}

import { IsString, IsEmail, MinLength } from "class-validator";

export class CreateUserDto {
  @IsString()
  @MinLength(3)
  name: string;

  @IsEmail()
  email: string;

  @IsOptional()
  @IsInt()
  age: number;
}

@Controller("users")
export class UserController {
  @Post()
  create(@Body() createUserDto: CreateUserDto) {
    // Validation happens automatically
    return this.userService.create(createUserDto);
  }
}

npm install @nestjs/typeorm typeorm sqlite3

import { Module } from "@nestjs/common";
import { TypeOrmModule } from "@nestjs/typeorm";
import { User } from "./entities/user.entity";
import { UserService } from "./user.service";
import { UserController } from "./user.controller";

@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: "sqlite",
      database: "db.sqlite",
      entities: [User],
      synchronize: true,
    }),
    TypeOrmModule.forFeature([User]),
  ],
  controllers: [UserController],
  providers: [UserService],
})
export class AppModule {}

@Entity()
export class User {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  name: string;

  @Column()
  email: string;
}

@Injectable()
export class UserService {
  constructor(
    @InjectRepository(User)
    private userRepository: Repository<User>
  ) {}

  findAll() {
    return this.userRepository.find();
  }

  create(createUserDto: CreateUserDto) {
    const user = this.userRepository.create(createUserDto);
    return this.userRepository.save(user);
  }
}

import { HttpException, HttpStatus } from "@nestjs/common";

@Get(":id")
getUser(@Param("id") id: string) {
  const user = this.userService.findOne(parseInt(id));
  if (!user) {
    throw new HttpException("User not found", HttpStatus.NOT_FOUND);
  }
  return user;
}

// Custom exception filter
@Catch(HttpException)
export class HttpExceptionFilter implements ExceptionFilter {
  catch(exception: HttpException, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const response = ctx.getResponse<Response>();
    const status = exception.getStatus();

    response.status(status).json({
      statusCode: status,
      message: exception.getResponse(),
    });
  }
}

// Use in main.ts
app.useGlobalFilters(new HttpExceptionFilter());

import { Test, TestingModule } from "@nestjs/testing";
import { UserController } from "./user.controller";
import { UserService } from "./user.service";

describe("UserController", () => {
  let controller: UserController;
  let service: UserService;

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      controllers: [UserController],
      providers: [
        {
          provide: UserService,
          useValue: {
            findAll: jest.fn().mockReturnValue([]),
          },
        },
      ],
    }).compile();

    controller = module.get<UserController>(UserController);
    service = module.get<UserService>(UserService);
  });

  it("should find all users", () => {
    expect(controller.findAll()).toEqual([]);
  });
});