Role-Based Access Control

export interface AuthenticatedUser {
  id: string;
  email: string;
  roles: Role[];
}

request.user = {
  id: 'user-123',
  email: 'editor@example.com',
  roles: [Role.Editor],
};

// src/auth/roles.decorator.ts
import { SetMetadata } from '@nestjs/common';
import { Role } from './role.enum';

export const ROLES_KEY = 'roles';

export const Roles = (...roles: Role[]) => SetMetadata(ROLES_KEY, roles);

@Roles(Role.Admin)
remove(id: string) {
  // ...
}

@Roles(Role.Admin, Role.Editor)
update(id: string) {
  // ...
}

// src/auth/roles.guard.ts
import {
  CanActivate,
  ExecutionContext,
  ForbiddenException,
  Injectable,
  UnauthorizedException,
} from '@nestjs/common';
import { Reflector } from '@nestjs/core';
import { Request } from 'express';
import { ROLES_KEY } from './roles.decorator';
import { Role } from './role.enum';

interface AuthenticatedUser {
  id: string;
  email: string;
  roles: Role[];
}

type RequestWithUser = Request & {
  user?: AuthenticatedUser;
};

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

  canActivate(context: ExecutionContext): boolean {
    const requiredRoles = this.reflector.getAllAndOverride<Role[]>(
      ROLES_KEY,
      [context.getHandler(), context.getClass()],
    );

    // Якщо ролі не вказані, маршрут не має додаткового RBAC-обмеження.
    if (!requiredRoles || requiredRoles.length === 0) {
      return true;
    }

    const request = context
      .switchToHttp()
      .getRequest<RequestWithUser>();

    const user = request.user;

    if (!user) {
      throw new UnauthorizedException(
        'Користувач не автентифікований',
      );
    }

    const hasRequiredRole = requiredRoles.some((role) =>
      user.roles?.includes(role),
    );

    if (!hasRequiredRole) {
      throw new ForbiddenException(
        'Недостатньо прав для виконання цієї дії',
      );
    }

    return true;
  }
}

const requiredRoles = this.reflector.getAllAndOverride<Role[]>(
  ROLES_KEY,
  [context.getHandler(), context.getClass()],
);

@Roles(Role.Admin)

@Roles(Role.Editor)

const hasRequiredRole = requiredRoles.some((role) =>
  user.roles?.includes(role),
);

// src/articles/articles.controller.ts
import {
  Body,
  Controller,
  Delete,
  Get,
  Param,
  Patch,
  Post,
  UseGuards,
} from '@nestjs/common';
import { AuthGuard } from '@nestjs/passport';
import { Role } from '../auth/role.enum';
import { Roles } from '../auth/roles.decorator';
import { RolesGuard } from '../auth/roles.guard';

const JwtAuthGuard = AuthGuard('jwt');

@Controller('articles')
@UseGuards(JwtAuthGuard, RolesGuard)
export class ArticlesController {
  @Get()
  @Roles(Role.Admin, Role.Editor, Role.Viewer)
  findAll() {
    return {
      message: 'Список статей',
    };
  }

  @Post()
  @Roles(Role.Admin, Role.Editor)
  create(@Body() body: { title: string; content: string }) {
    return {
      message: 'Статтю створено',
      body,
    };
  }

  @Patch(':id')
  @Roles(Role.Admin, Role.Editor)
  update(
    @Param('id') id: string,
    @Body() body: { title?: string; content?: string },
  ) {
    return {
      message: `Статтю ${id} оновлено`,
      body,
    };
  }

  @Delete(':id')
  @Roles(Role.Admin)
  remove(@Param('id') id: string) {
    return {
      message: `Статтю ${id} видалено`,
    };
  }
}

@UseGuards(JwtAuthGuard, RolesGuard)

// src/articles/articles.module.ts
import { Module } from '@nestjs/common';
import { ArticlesController } from './articles.controller';
import { RolesGuard } from '../auth/roles.guard';

@Module({
  controllers: [ArticlesController],
  providers: [RolesGuard],
})
export class ArticlesModule {}

@Controller('admin')
@Roles(Role.Admin)
@UseGuards(JwtAuthGuard, RolesGuard)
export class AdminController {
  @Get('dashboard')
  getDashboard() {
    return {
      message: 'Панель адміністратора',
    };
  }
}

@Controller('admin')
@Roles(Role.Admin)
@UseGuards(JwtAuthGuard, RolesGuard)
export class AdminController {
  @Get('dashboard')
  getDashboard() {
    return {
      message: 'Лише для адміністраторів',
    };
  }

  @Get('profile')
  @Roles(Role.Admin, Role.Editor)
  getProfile() {
    return {
      message: 'Для адміністраторів і редакторів',
    };
  }
}

throw new UnauthorizedException();

throw new ForbiddenException();

@Roles('admni')