Kurs Next.js · Moduł 7: Uwierzytelnianie i autoryzacja
Role i uprawnienia użytkowników
W tej lekcji15
W poprzednich modułach poznaliśmy podstawy uwierzytelniania, podłączanie zewnętrznych dostawców oraz zarządzanie sesjami i tokenami. Teraz zajmiemy się kolejnym kluczowym elementem bezpieczeństwa aplikacji - systemem ról i uprawnień użytkowników, czyli autoryzacją.
Podczas gdy uwierzytelnianie odpowiada na pytanie "Kim jesteś?", autoryzacja odpowiada na pytanie "Co możesz zrobić?". Solidny system ról i uprawnień jest niezbędny w każdej aplikacji, która wymaga różnych poziomów dostępu dla różnych użytkowników.
Podstawowe koncepcje ról i uprawnień
Zanim przejdziemy do implementacji, zrozummy podstawowe koncepcje:
- Role - kategorie użytkowników z podobnymi poziomami dostępu (np. użytkownik, moderator, administrator)
- Uprawnienia - konkretne działania, które może wykonać użytkownik (np. tworzenie postów, edycja profili, usuwanie kont)
- RBAC (Role-Based Access Control) - kontrola dostępu oparta na rolach, gdzie uprawnienia są przypisane do ról, a role do użytkowników
- ABAC (Attribute-Based Access Control) - bardziej zaawansowany model, gdzie decyzje o dostępie są podejmowane na podstawie różnych atrybutów (rola, czas, lokalizacja, itp.)
Model danych dla ról i uprawnień
Zacznijmy od zdefiniowania odpowiedniego modelu danych w Prisma:
// prisma/schema.prisma
model User {
id String @id @default(cuid())
name String?
email String? @unique
emailVerified DateTime?
image String?
password String?
accounts Account[]
sessions Session[]
role Role @relation(fields: [roleId], references: [id])
roleId String
permissions UserPermission[]
createdAt DateTime @default(now())
updatedAt DateTime @updatedAt
}
model Role {
id String @id @default(cuid())
name String @unique
description String?
users User[]
permissions RolePermission[]
createdAt DateTime @default(now())
updatedAt DateTime @updatedAt
}
model Permission {
id String @id @default(cuid())
name String @unique
description String?
roles RolePermission[]
users UserPermission[]
createdAt DateTime @default(now())
updatedAt DateTime @updatedAt
}
model RolePermission {
id String @id @default(cuid())
role Role @relation(fields: [roleId], references: [id], onDelete: Cascade)
roleId String
permission Permission @relation(fields: [permissionId], references: [id], onDelete: Cascade)
permissionId String
createdAt DateTime @default(now())
updatedAt DateTime @updatedAt
@@unique([roleId, permissionId])
}
model UserPermission {
id String @id @default(cuid())
user User @relation(fields: [userId], references: [id], onDelete: Cascade)
userId String
permission Permission @relation(fields: [permissionId], references: [id], onDelete: Cascade)
permissionId String
granted Boolean @default(true) // true = nadane, false = odebrane
createdAt DateTime @default(now())
updatedAt DateTime @updatedAt
@@unique([userId, permissionId])
}Ten model wspiera:
- Hierarchiczne role - użytkownicy mają przypisane role
- Uprawnienia oparte na rolach - role mają zestawy uprawnień
- Indywidualne uprawnienia - poszczególni użytkownicy mogą mieć nadane lub odebrane specyficzne uprawnienia, niezależnie od ich roli
Inicjalizacja podstawowych ról i uprawnień
Stwórzmy skrypt inicjalizujący podstawowe role i uprawnienia w naszej aplikacji:
// prisma/seed.ts
import { PrismaClient } from '@prisma/client';
const prisma = new PrismaClient();
async function main() {
// Utworzenie podstawowych ról
const roles = [
{
name: 'admin',
description: 'Administrator z pełnym dostępem do systemu'
},
{
name: 'moderator',
description: 'Moderator z dostępem do zarządzania zawartością'
},
{
name: 'user',
description: 'Standardowy użytkownik z podstawowymi uprawnieniami'
},
{
name: 'guest',
description: 'Gość z minimalnym dostępem tylko do odczytu'
}
];
for (const role of roles) {
await prisma.role.upsert({
where: { name: role.name },
update: {},
create: role,
});
}
// Utworzenie podstawowych uprawnień
const permissions = [
// Uprawnienia użytkowników
{ name: 'user:read', description: 'Może widzieć profile użytkowników' },
{ name: 'user:create', description: 'Może tworzyć nowych użytkowników' },
{ name: 'user:update', description: 'Może aktualizować dane użytkowników' },
{ name: 'user:delete', description: 'Może usuwać użytkowników' },
// Uprawnienia zawartości
{ name: 'content:read', description: 'Może czytać zawartość' },
{ name: 'content:create', description: 'Może tworzyć nową zawartość' },
{ name: 'content:update', description: 'Może aktualizować zawartość' },
{ name: 'content:delete', description: 'Może usuwać zawartość' },
{ name: 'content:publish', description: 'Może publikować zawartość' },
// Uprawnienia administracyjne
{ name: 'admin:access', description: 'Ma dostęp do panelu administracyjnego' },
{ name: 'admin:settings', description: 'Może zmieniać ustawienia systemu' },
{ name: 'admin:roles', description: 'Może zarządzać rolami i uprawnieniami' },
];
for (const permission of permissions) {
await prisma.permission.upsert({
where: { name: permission.name },
update: {},
create: permission,
});
}
// Przypisanie uprawnień do ról
const rolePermissions = [
// Uprawnienia administratora
{ roleName: 'admin', permissionNames: permissions.map(p => p.name) },
// Uprawnienia moderatora
{
roleName: 'moderator',
permissionNames: [
'user:read',
'content:read', 'content:create', 'content:update', 'content:delete', 'content:publish',
'admin:access',
]
},
// Uprawnienia standardowego użytkownika
{
roleName: 'user',
permissionNames: [
'user:read',
'content:read', 'content:create', 'content:update',
]
},
// Uprawnienia gościa
{
roleName: 'guest',
permissionNames: [
'user:read',
'content:read',
]
},
];
for (const { roleName, permissionNames } of rolePermissions) {
const role = await prisma.role.findUnique({ where: { name: roleName } });
if (role) {
for (const permName of permissionNames) {
const permission = await prisma.permission.findUnique({
where: { name: permName }
});
if (permission) {
await prisma.rolePermission.upsert({
where: {
roleId_permissionId: {
roleId: role.id,
permissionId: permission.id
}
},
update: {},
create: {
roleId: role.id,
permissionId: permission.id
}
});
}
}
}
}
// Utworzenie użytkownika administracyjnego (jeśli nie istnieje)
const adminRole = await prisma.role.findUnique({ where: { name: 'admin' } });
if (adminRole) {
const adminEmail = 'admin@example.com';
const existingAdmin = await prisma.user.findUnique({
where: { email: adminEmail }
});
if (!existingAdmin) {
await prisma.user.create({
data: {
name: 'Administrator',
email: adminEmail,
// W produkcji hasło powinno być zahaszowane!
password: '$2a$10$iqJSHD.BGr0E2IxQwYgJmeP3NvhPrXAeLSaGCj6IR/XU5QtjVu5Tm', // "secret"
roleId: adminRole.id,
}
});
console.log('Utworzono użytkownika administracyjnego');
}
}
console.log('Inicjalizacja ról i uprawnień zakończona pomyślnie');
}
main()
.catch((e) => {
console.error(e);
process.exit(1);
})
.finally(async () => {
await prisma.$disconnect();
});Aby uruchomić ten skrypt, dodaj następującą konfigurację do package.json:
"prisma": {
"seed": "ts-node prisma/seed.ts"
},
"scripts": {
"db:seed": "prisma db seed"
}Rozszerzenie typu sesji NextAuth
Aby mieć dostęp do informacji o roli użytkownika w sesji NextAuth, rozszerzmy typy:
// types/next-auth.d.ts
import { DefaultSession } from 'next-auth';
declare module 'next-auth' {
interface Session {
user: {
id: string;
role: string;
permissions: string[];
} & DefaultSession['user'];
}
interface User {
role: string;
roleId: string;
permissions: string[];
}
}
declare module 'next-auth/jwt' {
interface JWT {
userId: string;
role: string;
permissions: string[];
}
}Implementacja konfiguracji NextAuth
Teraz zmodyfikujmy konfigurację NextAuth, aby uwzględniała role i uprawnienia:
// app/api/auth/[...nextauth]/route.ts
import NextAuth from 'next-auth';
import { authOptions } from '@/lib/auth';
const handler = NextAuth(authOptions);
export { handler as GET, handler as POST };
// lib/auth.ts
import { NextAuthOptions } from 'next-auth';
import { PrismaAdapter } from '@auth/prisma-adapter';
import { prisma } from '@/lib/prisma';
import CredentialsProvider from 'next-auth/providers/credentials';
import GoogleProvider from 'next-auth/providers/google';
import { compare } from 'bcrypt';
export const authOptions: NextAuthOptions = {
adapter: PrismaAdapter(prisma),
providers: [
GoogleProvider({
clientId: process.env.GOOGLE_CLIENT_ID!,
clientSecret: process.env.GOOGLE_CLIENT_SECRET!,
}),
CredentialsProvider({
name: 'Credentials',
credentials: {
email: { label: "Email", type: "email" },
password: { label: "Hasło", type: "password" }
},
async authorize(credentials) {
if (!credentials?.email || !credentials?.password) {
return null;
}
const user = await prisma.user.findUnique({
where: { email: credentials.email },
include: {
role: true,
permissions: {
include: {
permission: true,
},
},
},
});
if (!user || !user.password) {
return null;
}
const isPasswordValid = await compare(credentials.password, user.password);
if (!isPasswordValid) {
return null;
}
// Pobierz uprawnienia roli
const rolePermissions = await prisma.rolePermission.findMany({
where: { roleId: user.roleId },
include: { permission: true },
});
// Utwórz listę uprawnień (uprawnienia roli + indywidualne uprawnienia)
const allPermissions = new Set<string>();
// Dodaj uprawnienia roli
rolePermissions.forEach(rp => {
allPermissions.add(rp.permission.name);
});
// Dodaj/usuń indywidualne uprawnienia użytkownika
user.permissions.forEach(up => {
if (up.granted) {
allPermissions.add(up.permission.name);
} else {
allPermissions.delete(up.permission.name);
}
});
return {
id: user.id,
email: user.email,
name: user.name,
image: user.image,
role: user.role.name,
roleId: user.roleId,
permissions: Array.from(allPermissions),
};
},
}),
],
callbacks: {
async jwt({ token, user }) {
if (user) {
token.userId = user.id;
token.role = user.role;
token.permissions = user.permissions;
}
return token;
},
async session({ session, token }) {
if (session.user) {
session.user.id = token.userId;
session.user.role = token.role;
session.user.permissions = token.permissions;
}
return session;
},
},
pages: {
signIn: '/auth/login',
error: '/auth/error',
},
session: {
strategy: 'jwt',
},
};Narzędzia do autoryzacji
Teraz stwórzmy narzędzia do łatwego sprawdzania ról i uprawnień użytkowników:
// lib/auth-utils.ts
import { getServerSession } from 'next-auth/next';
import { authOptions } from '@/lib/auth';
import { redirect } from 'next/navigation';
import { Session } from 'next-auth';
// Funkcje pomocnicze do sprawdzania ról i uprawnień
export function hasRole(session: Session | null, role: string | string[]): boolean {
if (!session?.user?.role) return false;
if (Array.isArray(role)) {
return role.includes(session.user.role);
}
return session.user.role === role;
}
export function hasPermission(session: Session | null, permission: string | string[]): boolean {
if (!session?.user?.permissions) return false;
if (Array.isArray(permission)) {
return permission.some(p => session.user.permissions.includes(p));
}
return session.user.permissions.includes(permission);
}
// Funkcja serwerowa - sprawdza rolę i przekierowuje, jeśli brak dostępu
export async function requireRole(role: string | string[], redirectTo: string = '/auth/unauthorized') {
const session = await getServerSession(authOptions);
if (!session) {
redirect('/auth/login');
}
if (!hasRole(session, role)) {
redirect(redirectTo);
}
return session;
}
// Funkcja serwerowa - sprawdza uprawnienie i przekierowuje, jeśli brak dostępu
export async function requirePermission(permission: string | string[], redirectTo: string = '/auth/unauthorized') {
const session = await getServerSession(authOptions);
if (!session) {
redirect('/auth/login');
}
if (!hasPermission(session, permission)) {
redirect(redirectTo);
}
return session;
}Implementacja komponentów ochrony dostępu
Utwórzmy teraz komponenty klienckie, które pozwolą na łatwe kontrolowanie dostępu do części interfejsu użytkownika:
// components/RoleGuard.tsx
'use client';
import { useSession } from 'next-auth/react';
import { ReactNode } from 'react';
import { hasRole } from '@/lib/auth-utils';
interface RoleGuardProps {
children: ReactNode;
role: string | string[];
fallback?: ReactNode;
}
export function RoleGuard({ children, role, fallback = null }: RoleGuardProps) {
const { data: session } = useSession();
if (!hasRole(session, role)) {
return fallback;
}
return <>{children}</>;
}
// components/PermissionGuard.tsx
'use client';
import { useSession } from 'next-auth/react';
import { ReactNode } from 'react';
import { hasPermission } from '@/lib/auth-utils';
interface PermissionGuardProps {
children: ReactNode;
permission: string | string[];
fallback?: ReactNode;
}
export function PermissionGuard({ children, permission, fallback = null }: PermissionGuardProps) {
const { data: session } = useSession();
if (!hasPermission(session, permission)) {
return fallback;
}
return <>{children}</>;
}
// components/AdminOnly.tsx
'use client';
import { RoleGuard } from '@/components/RoleGuard';
import { ReactNode } from 'react';
export function AdminOnly({ children, fallback = null }: { children: ReactNode, fallback?: ReactNode }) {
return (
<RoleGuard role="admin" fallback={fallback}>
{children}
</RoleGuard>
);
}Implementacja middleware
Możemy również zaimplementować middleware do kontroli dostępu do całych ścieżek:
// middleware.ts
import { NextResponse } from 'next/server';
import { NextRequest } from 'next/server';
import { getToken } from 'next-auth/jwt';
export async function middleware(request: NextRequest) {
const token = await getToken({ req: request });
// Ścieżki administracyjne
if (request.nextUrl.pathname.startsWith('/admin')) {
if (!token) {
return NextResponse.redirect(new URL('/auth/login?callbackUrl=/admin', request.url));
}
// Sprawdź, czy użytkownik ma rolę administratora
if (token.role !== 'admin') {
return NextResponse.redirect(new URL('/auth/unauthorized', request.url));
}
}
// Ścieżki moderatorów
if (request.nextUrl.pathname.startsWith('/moderator')) {
if (!token) {
return NextResponse.redirect(new URL('/auth/login?callbackUrl=/moderator', request.url));
}
// Sprawdź, czy użytkownik ma rolę administratora lub moderatora
if (token.role !== 'admin' && token.role !== 'moderator') {
return NextResponse.redirect(new URL('/auth/unauthorized', request.url));
}
}
// Ścieżki chronione - dostępne tylko dla zalogowanych użytkowników
if (
request.nextUrl.pathname.startsWith('/dashboard') ||
request.nextUrl.pathname.startsWith('/profile') ||
request.nextUrl.pathname.startsWith('/settings')
) {
if (!token) {
const callbackUrl = encodeURIComponent(request.nextUrl.pathname);
return NextResponse.redirect(new URL(`/auth/login?callbackUrl=${callbackUrl}`, request.url));
}
}
// Zabezpieczenie API endpoints
if (request.nextUrl.pathname.startsWith('/api/protected')) {
if (!token) {
return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
}
// Można dodać dodatkowe sprawdzanie uprawnień w zależności od ścieżki API
if (request.nextUrl.pathname.startsWith('/api/protected/admin') && token.role !== 'admin') {
return NextResponse.json({ error: 'Forbidden' }, { status: 403 });
}
}
return NextResponse.next();
}
export const config = {
matcher: [
'/admin/:path*',
'/moderator/:path*',
'/dashboard/:path*',
'/profile/:path*',
'/settings/:path*',
'/api/protected/:path*',
],
};Przykłady użycia w aplikacji
1. Ochrona tras za pomocą funkcji serwerowych
// app/admin/dashboard/page.tsx
import { requireRole } from '@/lib/auth-utils';
export default async function AdminDashboardPage() {
// Przekieruje jeśli użytkownik nie jest administratorem
const session = await requireRole('admin');
return (
<div className="p-6">
<h1 className="text-2xl font-bold mb-4">Panel administracyjny</h1>
<p>Witaj, {session.user.name}! Masz pełny dostęp administracyjny.</p>
{/* Zawartość dostępna tylko dla administratorów */}
</div>
);
}
// app/content/edit/[id]/page.tsx
import { requirePermission } from '@/lib/auth-utils';
export default async function EditContentPage({ params }: { params: Promise<{ id: string }> }) {
// Przekieruje jeśli użytkownik nie ma uprawnienia do edycji zawartości
const session = await requirePermission('content:update');
// Pobierz zawartość do edycji
const content = await fetchContent((await params).id);
return (
<div className="p-6">
<h1 className="text-2xl font-bold mb-4">Edycja zawartości</h1>
{/* Formularz edycji */}
</div>
);
}2. Ochrona komponentów UI
// components/NavBar.tsx
'use client';
import { useSession } from 'next-auth/react';
import Link from 'next/link';
import { AdminOnly } from '@/components/AdminOnly';
import { RoleGuard } from '@/components/RoleGuard';
import { PermissionGuard } from '@/components/PermissionGuard';
export function NavBar() {
const { data: session } = useSession();
return (
<nav className="bg-white shadow-sm">
<div className="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8">
<div className="flex justify-between h-16">
<div className="flex space-x-8 items-center">
<Link href="/" className="font-bold text-xl">MojaAplikacja</Link>
<Link href="/dashboard">Dashboard</Link>
{/* Link widoczny tylko dla moderatorów i administratorów */}
<RoleGuard role={['admin', 'moderator']}>
<Link href="/moderator/content" className="text-blue-600">
Zarządzanie zawartością
</Link>
</RoleGuard>
{/* Link tylko dla administratorów */}
<AdminOnly>
<Link href="/admin/dashboard" className="text-red-600">
Panel administratora
</Link>
</AdminOnly>
{/* Link dla użytkowników z uprawnieniem do tworzenia zawartości */}
<PermissionGuard permission="content:create">
<Link href="/content/new" className="text-green-600">
Utwórz zawartość
</Link>
</PermissionGuard>
</div>
<div className="flex items-center">
{session ? (
<div className="flex items-center space-x-4">
<span>{session.user.name}</span>
<span className="px-2 py-1 bg-gray-200 rounded-full text-xs">
{session.user.role}
</span>
</div>
) : (
<Link href="/auth/login">Zaloguj się</Link>
)}
</div>
</div>
</div>
</nav>
);
}3. Implementacja Route Handlers z autoryzacją
// app/api/protected/users/route.ts
import { NextResponse } from 'next/server';
import { getServerSession } from 'next-auth/next';
import { authOptions } from '@/lib/auth';
import { hasPermission } from '@/lib/auth-utils';
import { prisma } from '@/lib/prisma';
export async function GET() {
const session = await getServerSession(authOptions);
if (!session) {
return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
}
// Sprawdź, czy użytkownik ma uprawnienie do odczytu użytkowników
if (!hasPermission(session, 'user:read')) {
return NextResponse.json({ error: 'Forbidden' }, { status: 403 });
}
try {
const users = await prisma.user.findMany({
select: {
id: true,
name: true,
email: true,
image: true,
role: {
select: {
name: true,
},
},
createdAt: true,
}
});
return NextResponse.json(users);
} catch (error) {
console.error('Error fetching users:', error);
return NextResponse.json(
{ error: 'Failed to fetch users' },
{ status: 500 }
);
}
}
// app/api/protected/users/[id]/route.ts
import { NextResponse } from 'next/server';
import { getServerSession } from 'next-auth/next';
import { authOptions } from '@/lib/auth';
import { hasPermission } from '@/lib/auth-utils';
import { prisma } from '@/lib/prisma';
export async function DELETE(
request: Request,
{ params }: { params: Promise<{ id: string }> }
) {
const session = await getServerSession(authOptions);
if (!session) {
return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
}
// Sprawdź, czy użytkownik ma uprawnienie do usuwania użytkowników
if (!hasPermission(session, 'user:delete')) {
return NextResponse.json({ error: 'Forbidden' }, { status: 403 });
}
try {
// Sprawdź, czy użytkownik nie próbuje usunąć samego siebie
if ((await params).id === session.user.id) {
return NextResponse.json(
{ error: 'Cannot delete your own account' },
{ status: 400 }
);
}
// Sprawdź, czy użytkownik nie próbuje usunąć administratora (jeśli sam nie jest administratorem)
if (session.user.role !== 'admin') {
const userToDelete = await prisma.user.findUnique({
where: { id: (await params).id },
include: { role: true },
});
if (userToDelete?.role.name === 'admin') {
return NextResponse.json(
{ error: 'Cannot delete admin accounts' },
{ status: 403 }
);
}
}
// Usuń użytkownika
await prisma.user.delete({
where: { id: (await params).id },
});
return NextResponse.json({ success: true });
} catch (error) {
console.error('Error deleting user:', error);
return NextResponse.json(
{ error: 'Failed to delete user' },
{ status: 500 }
);
}
}Panel administracyjny do zarządzania rolami i uprawnieniami
Fragment implementacji panelu administracyjnego do zarządzania rolami i uprawnieniami:
// app/admin/roles/page.tsx
import { requirePermission } from '@/lib/auth-utils';
import Link from 'next/link';
import { prisma } from '@/lib/prisma';
export default async function RolesAdminPage() {
await requirePermission('admin:roles');
const roles = await prisma.role.findMany({
include: {
_count: {
select: {
users: true,
permissions: true,
},
},
},
orderBy: {
name: 'asc',
},
});
return (
<div className="p-6">
<div className="flex justify-between items-center mb-6">
<h1 className="text-2xl font-bold">Zarządzanie rolami</h1>
<Link
href="/admin/roles/new"
className="bg-blue-600 text-white px-4 py-2 rounded-md hover:bg-blue-700"
>
Dodaj nową rolę
</Link>
</div>
<div className="bg-white shadow overflow-hidden rounded-md">
<table className="min-w-full divide-y divide-gray-200">
<thead className="bg-gray-50">
<tr>
<th className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">
Nazwa
</th>
<th className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">
Opis
</th>
<th className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">
Użytkowników
</th>
<th className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">
Uprawnień
</th>
<th className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">
Akcje
</th>
</tr>
</thead>
<tbody className="bg-white divide-y divide-gray-200">
{roles.map((role) => (
<tr key={role.id}>
<td className="px-6 py-4 whitespace-nowrap text-sm font-medium text-gray-900">
{role.name}
</td>
<td className="px-6 py-4 whitespace-nowrap text-sm text-gray-500">
{role.description}
</td>
<td className="px-6 py-4 whitespace-nowrap text-sm text-gray-500">
{role._count.users}
</td>
<td className="px-6 py-4 whitespace-nowrap text-sm text-gray-500">
{role._count.permissions}
</td>
<td className="px-6 py-4 whitespace-nowrap text-sm font-medium">
<Link
href={`/admin/roles/${role.id}`}
className="text-blue-600 hover:text-blue-900 mr-4"
>
Edytuj
</Link>
<Link
href={`/admin/roles/${role.id}/permissions`}
className="text-green-600 hover:text-green-900"
>
Uprawnienia
</Link>
</td>
</tr>
))}
</tbody>
</table>
</div>
</div>
);
}Debugowanie i diagnostyka uprawnień
Przydatne może być utworzenie komponentu diagnostycznego, który pokazuje bieżące role i uprawnienia zalogowanego użytkownika:
// components/PermissionDebugger.tsx
'use client';
import { useSession } from 'next-auth/react';
import { useState } from 'react';
export function PermissionDebugger() {
const { data: session, status } = useSession();
const [showDetails, setShowDetails] = useState(false);
if (status !== 'authenticated') {
return null;
}
return (
<div className="fixed bottom-4 right-4 p-4 bg-white border border-gray-300 rounded-lg shadow-lg max-w-md z-50">
<div className="flex justify-between items-center mb-2">
<h3 className="font-bold text-lg">Diagnostyka uprawnień</h3>
<button
onClick={() => setShowDetails(!showDetails)}
className="text-blue-600 hover:text-blue-800"
>
{showDetails ? 'Ukryj szczegóły' : 'Pokaż szczegóły'}
</button>
</div>
<div className="mb-2">
<span className="font-semibold">Użytkownik:</span> {session.user.name}
</div>
<div className="mb-2">
<span className="font-semibold">Rola:</span>
<span className="ml-2 px-2 py-1 bg-blue-100 text-blue-800 rounded-full text-xs">
{session.user.role}
</span>
</div>
{showDetails && (
<div>
<div className="font-semibold mb-1">Uprawnienia:</div>
<div className="max-h-40 overflow-y-auto">
{session.user.permissions.length > 0 ? (
<ul className="list-disc pl-5 space-y-1">
{session.user.permissions.sort().map((permission) => (
<li key={permission} className="text-sm">
{permission}
</li>
))}
</ul>
) : (
<p className="text-sm text-red-600">Brak uprawnień</p>
)}
</div>
</div>
)}
</div>
);
}Ten komponent można użyć podczas fazy rozwoju lub dla administratorów w środowisku produkcyjnym.
Rozszerzenie RBAC o dodatkowe warunki (ABAC)
Możemy rozszerzyć nasz system autoryzacji o dodatkowe warunki, wdrażając elementy kontroli dostępu opartej na atrybutach (ABAC):
// lib/auth-conditions.ts
import { Session } from 'next-auth';
interface AccessConditions {
isOwner?: (userId: string, resourceId: string) => Promise<boolean>;
isInSameTeam?: (userId: string, resourceId: string) => Promise<boolean>;
isWithinBusinessHours?: () => boolean;
isFromAllowedIP?: (ipAddress: string) => boolean;
// Można dodać więcej warunków według potrzeb
}
export async function checkAccessConditions(
session: Session | null,
permission: string,
resourceId: string,
conditions: AccessConditions,
ipAddress?: string
): Promise<boolean> {
// Najpierw sprawdź podstawowe uprawnienie
if (!session?.user?.permissions?.includes(permission)) {
return false;
}
// Jeśli to administrator, zawsze zezwól na dostęp
if (session.user.role === 'admin') {
return true;
}
// Sprawdź dodatkowe warunki
if (conditions.isOwner && resourceId) {
const isOwner = await conditions.isOwner(session.user.id, resourceId);
if (!isOwner) {
return false;
}
}
if (conditions.isInSameTeam && resourceId) {
const isInSameTeam = await conditions.isInSameTeam(session.user.id, resourceId);
if (!isInSameTeam) {
return false;
}
}
if (conditions.isWithinBusinessHours) {
const isWithinBusinessHours = conditions.isWithinBusinessHours();
if (!isWithinBusinessHours) {
return false;
}
}
if (conditions.isFromAllowedIP && ipAddress) {
const isFromAllowedIP = conditions.isFromAllowedIP(ipAddress);
if (!isFromAllowedIP) {
return false;
}
}
// Wszystkie warunki spełnione
return true;
}
// Przykładowe implementacje warunków
export async function isContentOwner(userId: string, contentId: string): Promise<boolean> {
const content = await prisma.content.findUnique({
where: { id: contentId },
select: { authorId: true },
});
return content?.authorId === userId;
}
export function isWithinBusinessHours(): boolean {
const now = new Date();
const hours = now.getHours();
const day = now.getDay(); // 0 = niedziela, 6 = sobota
// Godziny pracy: 9:00 - 17:00, od poniedziałku do piątku
return day >= 1 && day <= 5 && hours >= 9 && hours < 17;
}Przykład użycia:
// app/api/protected/content/[id]/route.ts
import { NextResponse } from 'next/server';
import { getServerSession } from 'next-auth/next';
import { authOptions } from '@/lib/auth';
import { checkAccessConditions, isContentOwner } from '@/lib/auth-conditions';
import { headers } from 'next/headers';
export async function PUT(
request: Request,
{ params }: { params: Promise<{ id: string }> }
) {
const session = await getServerSession(authOptions);
const headersList = await headers();
const ipAddress = headersList.get('x-forwarded-for') || 'unknown';
// Sprawdzamy uprawnienie 'content:update' oraz dodatkowe warunki
const hasAccess = await checkAccessConditions(
session,
'content:update',
(await params).id,
{ isOwner: isContentOwner },
ipAddress as string
);
if (!hasAccess) {
return NextResponse.json({ error: 'Forbidden' }, { status: 403 });
}
// Kontynuuj z aktualizacją zawartości
//
}Testowanie systemu ról i uprawnień
Przykładowy test jednostkowy dla funkcji sprawdzania uprawnień:
// __tests__/auth-utils.test.ts
import { hasPermission, hasRole } from '@/lib/auth-utils';
describe('Auth Utils', () => {
describe('hasRole', () => {
it('should return false for null session', () => {
expect(hasRole(null, 'admin')).toBe(false);
});
it('should return false if user has no role', () => {
const session = { user: {} } as any;
expect(hasRole(session, 'admin')).toBe(false);
});
it('should return true if user has the specified role', () => {
const session = { user: { role: 'admin' } } as any;
expect(hasRole(session, 'admin')).toBe(true);
});
it('should return false if user does not have the specified role', () => {
const session = { user: { role: 'user' } } as any;
expect(hasRole(session, 'admin')).toBe(false);
});
it('should return true if user has one of the specified roles', () => {
const session = { user: { role: 'moderator' } } as any;
expect(hasRole(session, ['admin', 'moderator'])).toBe(true);
});
});
describe('hasPermission', () => {
it('should return false for null session', () => {
expect(hasPermission(null, 'user:read')).toBe(false);
});
it('should return false if user has no permissions', () => {
const session = { user: {} } as any;
expect(hasPermission(session, 'user:read')).toBe(false);
});
it('should return true if user has the specified permission', () => {
const session = { user: { permissions: ['user:read', 'user:create'] } } as any;
expect(hasPermission(session, 'user:read')).toBe(true);
});
it('should return false if user does not have the specified permission', () => {
const session = { user: { permissions: ['user:read'] } } as any;
expect(hasPermission(session, 'user:delete')).toBe(false);
});
it('should return true if user has one of the specified permissions', () => {
const session = { user: { permissions: ['user:read', 'content:read'] } } as any;
expect(hasPermission(session, ['user:delete', 'content:read'])).toBe(true);
});
});
});Dobre praktyki i zalecenia
Minimalne uprawnienia - przydzielaj użytkownikom tylko niezbędne uprawnienia (zasada najmniejszych uprawnień)
Hierarchiczne role - projektuj role w sposób hierarchiczny, gdzie role wyższe zawierają wszystkie uprawnienia niższych ról plus dodatkowe
Rozdzielenie uwierzytelniania i autoryzacji - traktuj je jako oddzielne warstwy zabezpieczeń
Szczegółowe logi - rejestruj wszystkie próby dostępu do chronionych zasobów, szczególnie te nieudane
Regularne audyty - okresowo przeglądaj i weryfikuj przydzielone role i uprawnienia
Usuwanie nieużywanych uprawnień - systematycznie usuwaj nieużywane role i uprawnienia
Awaryjny dostęp - zapewnij mechanizm awaryjnego dostępu dla administratorów w przypadku problemów z systemem ról
Testowanie penetracyjne - regularnie testuj system pod kątem luk w zabezpieczeniach
Podsumowanie
W tym module zaimplementowaliśmy zaawansowany system ról i uprawnień dla aplikacji Next.js. Poznaliśmy:
- Model danych dla RBAC - jak projektować strukturę bazy danych wspierającą role i uprawnienia
- Integracja z NextAuth.js - jak rozszerzyć sesję o informacje o rolach i uprawnieniach
- Narzędzia do autoryzacji - implementacja funkcji pomocniczych do sprawdzania ról i uprawnień
- Zabezpieczanie różnych elementów aplikacji:
- Ochrona tras za pomocą middleware
- Ochrona komponentów za pomocą Guardów
- Zabezpieczanie API endpointów
- Rozszerzenie o ABAC - dodanie warunkowej autoryzacji opartej na różnych atrybutach
Solidny system ról i uprawnień jest fundamentem bezpieczeństwa aplikacji, zwłaszcza tych z wieloma typami użytkowników i złożonymi wymaganiami dostępu. Dzięki przedstawionym w tym module rozwiązaniom, możesz zbudować elastyczny i bezpieczny system autoryzacji dostosowany do potrzeb Twojej aplikacji.
W następnym module omówimy jak tworzyć middleware do ochrony tras, co stanowi dodatkową warstwę zabezpieczeń w aplikacjach Next.js.
Kod do tej lekcji: App.tsx
import React, { useState } from 'react';
// Demo: Role i uprawnienia uzytkownikow (RBAC)
type Role = 'admin' | 'editor' | 'viewer' | 'moderator';
interface Permission { id: string; name: string; description: string; }
const allPermissions: Permission[] = [
{ id: 'read', name: 'Odczyt', description: 'Przegladanie tresci' },
{ id: 'write', name: 'Zapis', description: 'Tworzenie nowych tresci' },
{ id: 'edit', name: 'Edycja', description: 'Modyfikacja tresci' },
{ id: 'delete', name: 'Usuwanie', description: 'Usuwanie tresci' },
{ id: 'publish', name: 'Publikacja', description: 'Publikowanie tresci' },
{ id: 'manage_users', name: 'Zarzadzanie', description: 'Zarzadzanie uzytkownikami' },
{ id: 'settings', name: 'Ustawienia', description: 'Ustawienia systemowe' },
{ id: 'moderate', name: 'Moderacja', description: 'Moderowanie komentarzy' },
];
const rolePermissions: Record<Role, string[]> = {
admin: ['read', 'write', 'edit', 'delete', 'publish', 'manage_users', 'settings', 'moderate'],
editor: ['read', 'write', 'edit', 'publish'],
moderator: ['read', 'edit', 'moderate', 'delete'],
viewer: ['read'],
};
const roleColors: Record<Role, string> = { admin: '#ef4444', editor: '#f59e0b', moderator: '#8b5cf6', viewer: '#64748b' };
const users = [
{ id: '1', name: 'Anna Nowak', role: 'admin' as Role },
{ id: '2', name: 'Piotr Wisniewski', role: 'editor' as Role },
{ id: '3', name: 'Maria Kowalczyk', role: 'moderator' as Role },
{ id: '4', name: 'Jan Lewandowski', role: 'viewer' as Role },
];
function RBACDemo() {
const [userList, setUserList] = useState(users);
const [selected, setSelected] = useState(users[0]);
const [testResult, setTestResult] = useState('');
const hasPermission = (role: Role, permId: string) => rolePermissions[role].includes(permId);
const changeRole = (userId: string, newRole: Role) => {
setUserList(prev => prev.map(u => u.id === userId ? { ...u, role: newRole } : u));
if (selected.id === userId) setSelected(prev => ({ ...prev, role: newRole }));
};
return (
<div style={{ background: '#0f0f23', minHeight: '100vh', padding: '20px', color: '#e0e0e0', fontFamily: 'system-ui' }}>
<h1 style={{ color: '#64ffda', marginBottom: '8px' }}>RBAC - Role i Uprawnienia</h1>
<p style={{ color: '#8892b0', marginBottom: '24px' }}>System rol i uprawnien uzytkownikow</p>
<div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '20px' }}>
<div>
<h3 style={{ color: '#64ffda' }}>Uzytkownicy</h3>
{userList.map(user => (
<div key={user.id} onClick={() => setSelected(user)} style={{
padding: '12px', marginBottom: '8px', borderRadius: '8px', cursor: 'pointer',
background: selected.id === user.id ? '#1a2a3e' : '#1a1a2e',
border: selected.id === user.id ? '1px solid #64ffda' : '1px solid #333',
}}>
<div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center' }}>
<strong>{user.name}</strong>
<select value={user.role} onChange={e => changeRole(user.id, e.target.value as Role)} onClick={e => e.stopPropagation()}
style={{ padding: '4px 8px', borderRadius: '4px', background: roleColors[user.role] + '30', color: roleColors[user.role], border: '1px solid ' + roleColors[user.role], fontSize: '12px' }}>
{(Object.keys(rolePermissions) as Role[]).map(r => <option key={r} value={r}>{r}</option>)}
</select>
</div>
</div>
))}
</div>
<div>
<h3 style={{ color: '#64ffda' }}>Uprawnienia: {selected.name}</h3>
{allPermissions.map(perm => {
const allowed = hasPermission(selected.role, perm.id);
return (
<div key={perm.id} onClick={() => setTestResult(allowed ? selected.name + ' MA: ' + perm.name : selected.name + ' NIE MA: ' + perm.name)} style={{
padding: '10px 14px', borderRadius: '6px', cursor: 'pointer', marginBottom: '6px',
background: allowed ? '#10b98120' : '#ef444420', border: allowed ? '1px solid #10b981' : '1px solid #ef4444',
display: 'flex', justifyContent: 'space-between', alignItems: 'center',
}}>
<div>
<strong style={{ color: allowed ? '#10b981' : '#ef4444' }}>{perm.name}</strong>
<div style={{ fontSize: '12px', color: '#8892b0' }}>{perm.description}</div>
</div>
<span>{allowed ? 'V' : 'X'}</span>
</div>
);
})}
</div>
</div>
{testResult && <div style={{ marginTop: '16px', padding: '12px', borderRadius: '8px', background: '#1a1a2e', border: '1px solid #333' }}>{testResult}</div>}
</div>
);
}
export default RBACDemo;Hasła z dokumentacji w tej lekcji
Widzisz błąd w tej lekcji?
Sprawdź się
Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.
1. Middleware w Next.js dla auth może być używane do:
2. RBAC (Role-Based Access Control) oznacza:
Zadania praktyczne w grze
- Edytor kodu
Zaimplementuj dashboard z kontrolą dostępu i rolami użytkowników
- Edytor kodu
Utwórz middleware.ts chroniący specific routes i redirectujący nieautoryzowanych użytkowników
- Układanie w pionie
Ułóż elementy w prawidłowej kolejności: import { notFound } → from 'next/navigat
- Klikanie w kolejności
Ułóż składnię konfiguracji providera OAuth w NextAuth
- Edytor kodu
Utwórz system ról (admin, user, moderator) z permissions checking i conditional rendering
Zadania po tej lekcji
- PytanieMiddleware w Next.js dla auth może być używane do:
- PytanieRBAC (Role-Based Access Control) oznacza:
- Zadanie z kodemPraktyka: Dashboard z kontrolą dostępu
- Zadanie z kodemPraktyka: Utwórz middleware.ts chroniący specific routes i
- Ułóż w kolejnościKolejność: import { notFound } → from 'next/navigation'
- Kliknij w kolejnościKonfiguracja provider OAuth
- Zadanie z kodemPraktyka: Utwórz system ról (admin, user, moderator) z