Kurs Next.js · Moduł 7: Uwierzytelnianie i autoryzacja

Role i uprawnienia użytkowników

20 min czytania ·
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:

  1. Role - kategorie użytkowników z podobnymi poziomami dostępu (np. użytkownik, moderator, administrator)
  2. Uprawnienia - konkretne działania, które może wykonać użytkownik (np. tworzenie postów, edycja profili, usuwanie kont)
  3. RBAC (Role-Based Access Control) - kontrola dostępu oparta na rolach, gdzie uprawnienia są przypisane do ról, a role do użytkowników
  4. 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:

  1. Hierarchiczne role - użytkownicy mają przypisane role
  2. Uprawnienia oparte na rolach - role mają zestawy uprawnień
  3. 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

  1. Minimalne uprawnienia - przydzielaj użytkownikom tylko niezbędne uprawnienia (zasada najmniejszych uprawnień)

  2. Hierarchiczne role - projektuj role w sposób hierarchiczny, gdzie role wyższe zawierają wszystkie uprawnienia niższych ról plus dodatkowe

  3. Rozdzielenie uwierzytelniania i autoryzacji - traktuj je jako oddzielne warstwy zabezpieczeń

  4. Szczegółowe logi - rejestruj wszystkie próby dostępu do chronionych zasobów, szczególnie te nieudane

  5. Regularne audyty - okresowo przeglądaj i weryfikuj przydzielone role i uprawnienia

  6. Usuwanie nieużywanych uprawnień - systematycznie usuwaj nieużywane role i uprawnienia

  7. Awaryjny dostęp - zapewnij mechanizm awaryjnego dostępu dla administratorów w przypadku problemów z systemem ról

  8. 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:

  1. Model danych dla RBAC - jak projektować strukturę bazy danych wspierającą role i uprawnienia
  2. Integracja z NextAuth.js - jak rozszerzyć sesję o informacje o rolach i uprawnieniach
  3. Narzędzia do autoryzacji - implementacja funkcji pomocniczych do sprawdzania ról i uprawnień
  4. Zabezpieczanie różnych elementów aplikacji:
    • Ochrona tras za pomocą middleware
    • Ochrona komponentów za pomocą Guardów
    • Zabezpieczanie API endpointów
  5. 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. 1. Middleware w Next.js dla auth może być używane do:

  2. 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

  1. PytanieMiddleware w Next.js dla auth może być używane do:
  2. PytanieRBAC (Role-Based Access Control) oznacza:
  3. Zadanie z kodemPraktyka: Dashboard z kontrolą dostępu
  4. Zadanie z kodemPraktyka: Utwórz middleware.ts chroniący specific routes i
  5. Ułóż w kolejnościKolejność: import { notFound } → from 'next/navigation'
  6. Kliknij w kolejnościKonfiguracja provider OAuth
  7. Zadanie z kodemPraktyka: Utwórz system ról (admin, user, moderator) z

Przydatne artykuły