Authorization на Server Components

session_id=...

import 'server-only';

import { cookies } from 'next/headers';

export type UserRole = 'user' | 'admin';

export type User = {
  id: string;
  email: string;
  role: UserRole;
};

type Session = {
  userId: string;
};

// У реальному застосунку ці дані зберігатимуться в базі даних або Redis.
const sessions = new Map<string, Session>([
  ['demo-session', { userId: 'user-1' }],
]);

const users = new Map<string, User>([
  [
    'user-1',
    {
      id: 'user-1',
      email: 'admin@example.com',
      role: 'admin',
    },
  ],
  [
    'user-2',
    {
      id: 'user-2',
      email: 'user@example.com',
      role: 'user',
    },
  ],
]);

export async function getCurrentUser(): Promise<User | null> {
  const cookieStore = await cookies();
  const sessionId = cookieStore.get('session_id')?.value;

  if (!sessionId) {
    return null;
  }

  const session = sessions.get(sessionId);

  if (!session) {
    return null;
  }

  return users.get(session.userId) ?? null;
}

import 'server-only';

export type Report = {
  id: string;
  title: string;
  revenue: number;
};

const reports: Report[] = [
  {
    id: 'report-1',
    title: 'Звіт за січень',
    revenue: 125_000,
  },
  {
    id: 'report-2',
    title: 'Звіт за лютий',
    revenue: 142_500,
  },
];

export async function getAdminReports(): Promise<Report[]> {
  // Тут у реальному застосунку буде запит до бази даних.
  return reports;
}

import { redirect } from 'next/navigation';

import { getCurrentUser } from '@/lib/auth';
import { getAdminReports } from '@/lib/reports';

export default async function AdminPage() {
  const user = await getCurrentUser();

  if (!user) {
    redirect('/login');
  }

  if (user.role !== 'admin') {
    redirect('/forbidden');
  }

  const reports = await getAdminReports();

  return (
    <main>
      <h1>Панель адміністратора</h1>

      <p>Користувач: {user.email}</p>

      <ul>
        {reports.map((report) => (
          <li key={report.id}>
            {report.title}: {report.revenue} грн
          </li>
        ))}
      </ul>
    </main>
  );
}

if (!user) {
  redirect('/login');
}

const user = await getCurrentUser();

if (!user) {
  redirect('/login');
}

// Тут user вже розглядається як User, а не User | null.
console.log(user.email);

import 'server-only';

export type Document = {
  id: string;
  ownerId: string;
  title: string;
};

const documents: Document[] = [
  {
    id: 'document-1',
    ownerId: 'user-1',
    title: 'Адміністративний документ',
  },
  {
    id: 'document-2',
    ownerId: 'user-2',
    title: 'Особистий документ',
  },
];

export async function getDocumentForUser(
  documentId: string,
  userId: string,
): Promise<Document | null> {
  const document = documents.find((item) => item.id === documentId);

  if (!document || document.ownerId !== userId) {
    return null;
  }

  return document;
}

import { notFound, redirect } from 'next/navigation';

import { getCurrentUser } from '@/lib/auth';
import { getDocumentForUser } from '@/lib/documents';

type DocumentPageProps = {
  params: Promise<{
    id: string;
  }>;
};

export default async function DocumentPage({
  params,
}: DocumentPageProps) {
  const user = await getCurrentUser();

  if (!user) {
    redirect('/login');
  }

  const { id } = await params;
  const document = await getDocumentForUser(id, user.id);

  if (!document) {
    notFound();
  }

  return (
    <main>
      <h1>{document.title}</h1>
    </main>
  );
}

import 'server-only';

import { redirect } from 'next/navigation';

import { getCurrentUser, type User, type UserRole } from '@/lib/auth';

export async function requireUser(): Promise<User> {
  const user = await getCurrentUser();

  if (!user) {
    redirect('/login');
  }

  return user;
}

export async function requireRole(role: UserRole): Promise<User> {
  const user = await requireUser();

  if (user.role !== role) {
    redirect('/forbidden');
  }

  return user;
}

import { requireRole } from '@/lib/require-user';
import { getAdminReports } from '@/lib/reports';

export default async function AdminPage() {
  const user = await requireRole('admin');
  const reports = await getAdminReports();

  return (
    <main>
      <h1>Панель адміністратора</h1>
      <p>Користувач: {user.email}</p>

      <ul>
        {reports.map((report) => (
          <li key={report.id}>
            {report.title}: {report.revenue} грн
          </li>
        ))}
      </ul>
    </main>
  );
}

const response = await fetch('https://internal.example.test/reports', {
  cache: 'no-store',
});

const response = await fetch(
  `https://internal.example.test/users/${user.id}/reports`,
  {
    cache: 'no-store',
  },
);

import { requireRole } from '@/lib/require-user';
import { AdminFilters } from './AdminFilters';
import { getAdminReports } from '@/lib/reports';

export default async function AdminPage() {
  const user = await requireRole('admin');
  const reports = await getAdminReports();

  return (
    <main>
      <h1>Панель адміністратора</h1>

      <AdminFilters
        userEmail={user.email}
        reports={reports}
      />
    </main>
  );
}

'use server';

import { requireRole } from '@/lib/require-user';

export async function deleteReport(reportId: string) {
  const user = await requireRole('admin');

  // Перевірка виконана безпосередньо перед небезпечною операцією.
  await deleteReportFromDatabase(reportId, user.id);
}

'use client';

if (user?.role === 'admin') {
  return <AdminData />;
}

const reports = await getAdminReports();
const user = await getCurrentUser();

if (!user) {
  redirect('/login');
}

const role = searchParams.role;

if (role === 'admin') {
  // Небезпечно: значення контролює користувач.
}

const publicUser = {
  id: user.id,
  email: user.email,
};

document.ownerId === user.id