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

@Injectable()
export class ApiKeyMiddleware implements NestMiddleware {
  use(req: Request, res: Response, next: NextFunction) {
    const apiKey = req.headers['x-api-key'];
    
    if (!apiKey || apiKey !== process.env.VALID_API_KEY) {
      // Припинення обробки: надсилаємо відповідь напряму
      return res.status(401).json({
        statusCode: 401,
        message: 'Invalid API key',
        error: 'Unauthorized'
      });
    }
    
    // Продовжуємо обробку
    next();
  }
}

import { Injectable, CanActivate, ExecutionContext, ForbiddenException } from '@nestjs/common';
import { Reflector } from '@nestjs/core';

@Injectable()
export class RolesGuard implements CanActivate {
  constructor(private reflector: Reflector) {}

  canActivate(context: ExecutionContext): boolean {
    const requiredRoles = this.reflector.get<string[]>('roles', context.getHandler());
    if (!requiredRoles) {
      return true; // Немає вимог до ролей — дозволяємо
    }

    const request = context.switchToHttp().getRequest();
    const user = request.user;

    const hasRole = requiredRoles.some(role => user.roles?.includes(role));
    
    if (!hasRole) {
      // Припинення з чітким повідомленням про помилку
      throw new ForbiddenException('You do not have permission to access this resource');
    }

    return true;
  }
}

import { PipeTransform, Injectable, BadRequestException } from '@nestjs/common';

@Injectable()
export class ParsePositiveIntPipe implements PipeTransform<string, number> {
  transform(value: string): number {
    const val = parseInt(value, 10);
    
    if (isNaN(val)) {
      throw new BadRequestException(`"${value}" is not a valid integer`);
    }
    
    if (val <= 0) {
      throw new BadRequestException(`Value must be a positive integer, received: ${val}`);
    }
    
    return val;
  }
}

import { Controller, Get, Param, NotFoundException } from '@nestjs/common';
import { UsersService } from './users.service';

@Controller('users')
export class UsersController {
  constructor(private readonly usersService: UsersService) {}

  @Get(':id')
  async getUserById(@Param('id') id: string) {
    const user = await this.usersService.findById(id);
    
    if (!user) {
      // Припинення через бізнес-помилку
      throw new NotFoundException(`User with ID "${id}" not found`);
    }
    
    return user;
  }
}

interface ExecutionContext extends ArgumentsHost {
  // Отримати клас контролера
  getClass<T = any>(): Type<T>;
  
  // Отримати метод обробника
  getHandler(): Function;
  
  // Перемикання між контекстами (HTTP, RPC, WebSockets)
  switchToHttp(): HttpArgumentsHost;
  switchToRpc(): RpcArgumentsHost;
  switchToWs(): WsArgumentsHost;
  
  // Тип контексту: 'http' | 'rpc' | 'ws' | 'graphql'
  getType<TContext extends string = ContextType>(): TContext;
  
  // Аргументи обробника (масив параметрів методу)
  getArgs<T extends Array<any> = any[]>(): T;
  getArgByIndex<T = any>(index: number): T;
}

import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common';
import { Reflector } from '@nestjs/core';
import { Observable } from 'rxjs';

@Injectable()
export class AuthGuard implements CanActivate {
  constructor(private reflector: Reflector) {}

  canActivate(context: ExecutionContext): boolean | Promise<boolean> | Observable<boolean> {
    // Визначити тип запиту
    const contextType = context.getType();
    
    if (contextType === 'http') {
      // Отримати об'єкт Request для HTTP
      const request = context.switchToHttp().getRequest();
      const token = request.headers.authorization;
      
      // Отримати метадані з декоратора
      const isPublic = this.reflector.get<boolean>('isPublic', context.getHandler());
      
      if (isPublic) {
        return true; // Публічний маршрут — пропускаємо
      }
      
      return this.validateToken(token);
    }
    
    // Обробка інших типів контексту (WebSocket, GraphQL)
    return true;
  }

  private validateToken(token: string | undefined): boolean {
    // Логіка перевірки JWT-токена
    return !!token && token.startsWith('Bearer ');
  }
}

// Кастомний декоратор для позначення публічних маршрутів
import { SetMetadata } from '@nestjs/common';

export const Public = () => SetMetadata('isPublic', true);

// Використання в контролері
@Controller('auth')
export class AuthController {
  @Public() // Цей маршрут не вимагає автентифікації
  @Post('login')
  login(@Body() credentials: LoginDto) {
    // Логіка входу
  }

  @Get('profile')
  getProfile(@Req() request) {
    // Цей маршрут вимагає автентифікації (немає декоратора @Public)
    return request.user;
  }
}

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

@Injectable()
export class AuthMiddleware implements NestMiddleware {
  constructor(private jwtService: JwtService) {}

  use(req: Request, res: Response, next: NextFunction) {
    const token = req.headers.authorization?.replace('Bearer ', '');
    
    if (token) {
      try {
        const payload = this.jwtService.verify(token);
        // Збагачуємо запит: додаємо розпакований payload
        req['user'] = {
          id: payload.sub,
          email: payload.email,
          roles: payload.roles || []
        };
      } catch (error) {
        // Невалідний токен — не додаємо user, Guard відхилить запит
      }
    }
    
    next();
  }
}

@Injectable()
export class RolesGuard implements CanActivate {
  canActivate(context: ExecutionContext): boolean {
    const request = context.switchToHttp().getRequest();
    const user = request.user; // Доступний завдяки Middleware
    
    return user && user.roles.includes('admin');
  }
}

@Controller('articles')
export class ArticlesController {
  @Get(':id')
  findOne(
    @Param('id', ParseIntPipe) id: number, // Рядок → число
    @Query('published', ParseBoolPipe) published: boolean, // "true" → true
    @Query('tags', new ParseArrayPipe({ items: String, separator: ',' })) tags: string[]
  ) {
    // id: number, published: boolean, tags: string[]
    return this.articlesService.findOne(id, { published, tags });
  }
}

import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/core';
import { Observable } from 'rxjs';
import { map } from 'rxjs/operators';

export interface Response<T> {
  data: T;
  meta: {
    timestamp: string;
    path: string;
  };
}

@Injectable()
export class TransformInterceptor<T> implements NestInterceptor<T, Response<T>> {
  intercept(context: ExecutionContext, next: CallHandler): Observable<Response<T>> {
    const request = context.switchToHttp().getRequest();
    
    return next.handle().pipe(
      map(data => ({
        data, // Оригінальні дані від обробника
        meta: {
          timestamp: new Date().toISOString(),
          path: request.url
        }
      }))
    );
  }
}

{
  "data": {
    "id": 1,
    "email": "user@example.com"
  },
  "meta": {
    "timestamp": "2026-09-04T12:00:00.000Z",
    "path": "/api/users/1"
  }
}

// main.ts — глобальна конфігурація
import { NestFactory } from '@nestjs/core';
import { ValidationPipe } from '@nestjs/common';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  
  // Глобальний Pipe для валідації всіх DTO
  app.useGlobalPipes(new ValidationPipe({
    whitelist: true, // Видаляти невідомі поля
    forbidNonWhitelisted: true, // Викидати помилку для невідомих полів
    transform: true, // Автоматично трансформувати типи
  }));
  
  await app.listen(3000);
}
bootstrap();

// app.module.ts — реєстрація Middleware
import { Module, NestModule, MiddlewareConsumer } from '@nestjs/common';
import { APP_GUARD, APP_INTERCEPTOR } from '@nestjs/core';
import { LoggerMiddleware } from './middleware/logger.middleware';
import { JwtAuthGuard } from './guards/jwt-auth.guard';
import { TransformInterceptor } from './interceptors/transform.interceptor';
import { UsersModule } from './users/users.module';

@Module({
  imports: [UsersModule],
  providers: [
    // Глобальний Guard через DI
    {
      provide: APP_GUARD,
      useClass: JwtAuthGuard,
    },
    // Глобальний Interceptor
    {
      provide: APP_INTERCEPTOR,
      useClass: TransformInterceptor,
    },
  ],
})
export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    // Middleware застосовується до всіх маршрутів
    consumer.apply(LoggerMiddleware).forRoutes('*');
  }
}

// users.controller.ts — використання компонентів на різних рівнях
import { Controller, Get, Post, Body, Param, UseGuards, ParseIntPipe } from '@nestjs/common';
import { RolesGuard } from '../guards/roles.guard';
import { Roles } from '../decorators/roles.decorator';
import { Public } from '../decorators/public.decorator';
import { CreateUserDto } from './dto/create-user.dto';
import { UsersService } from './users.service';

@Controller('users')
@UseGuards(RolesGuard) // Guard рівня контролера
export class UsersController {
  constructor(private readonly usersService: UsersService) {}

  @Public() // Публічний маршрут — JwtAuthGuard пропустить
  @Get()
  findAll() {
    return this.usersService.findAll();
  }

  @Get(':id')
  findOne(@Param('id', ParseIntPipe) id: number) {
    // ParseIntPipe гарантує, що id — це число
    return this.usersService.findOne(id);
  }

  @Post()
  @Roles('admin') // Лише адміністратори
  create(@Body() dto: CreateUserDto) {
    // ValidationPipe автоматично валідує dto
    return this.usersService.create(dto);
  }
}