Kurs Next.js · Moduł 9: Integracje i zaawansowane funkcje
after() API - Wykonywanie kodu po odpowiedzi
W tej lekcji10
Użytkownik Metropolii Quantum 2150 kupuje bilet na lot orbitalny i czeka. Zamówienie zapisało się w 50 ms, ale serwer wciąż wysyła email, aktualizuje magazyn i loguje zdarzenie do systemu audytu, więc ekran potwierdzenia pojawia się po dwóch sekundach. Cypher, strażnik wydajności Metropolii, zna na to lekarstwo: API after() - funkcję pozwalającą wykonać kod po wysłaniu odpowiedzi do użytkownika. To idealne rozwiązanie dla zadań takich jak logowanie, analityka czy cleanup.
Problem: Blokujące operacje poboczne
Wyobraź sobie typowy scenariusz - użytkownik odwiedza stronę produktu, a ty chcesz:
- Zwrócić dane produktu (kluczowe)
- Zalogować wizytę (poboczne)
- Zaktualizować statystyki (poboczne)
- Wysłać event do analytics (poboczne)
Bez after() każde await wydłuża czas odpowiedzi, choć użytkownik potrzebuje tylko danych produktu. Tak wygląda Route Handler, w którym wszystko blokuje odpowiedź:
// Złe podejście - wszystko blokuje odpowiedź
export async function GET(request: Request) {
const product = await getProduct(id);
// Te operacje opóźniają odpowiedź!
await logVisit(id);
await updateStats(id);
await sendAnalytics('product_view', { id });
return Response.json(product);
}Użytkownik czeka na sumę czasów wszystkich czterech operacji, a trzy z nich w ogóle go nie dotyczą.
Rozwiązanie: after() API
Funkcja after() z next/server przyjmuje callback i planuje jego wykonanie PO zakończeniu odpowiedzi. Kod poboczny przenosimy do środka callbacku:
import { after } from 'next/server';
export async function GET(request: Request) {
const product = await getProduct(id);
// Zaplanuj wykonanie po odpowiedzi
after(async () => {
await logVisit(id);
await updateStats(id);
await sendAnalytics('product_view', { id });
});
// Odpowiedź wysyłana natychmiast!
return Response.json(product);
}Odpowiedź wychodzi natychmiast po pobraniu produktu, a logowanie i statystyki wykonują się chwilę później. Kolejność operacji w callbacku się nie zmieniła, zmienił się tylko moment ich startu.
Włączenie after() API
W Next.js 15.0 (od wersji RC do wydania stabilnego) funkcja nazywała się unstable_after i wymagała flagi eksperymentalnej:
// next.config.js - tylko Next.js 15.0 (unstable_after), od 15.1 zbędne
module.exports = {
experimental: {
after: true,
},
};Od Next.js 15.1 after() jest stabilne, więc ta flaga nie jest już potrzebna i w Next.js 16 po prostu importujesz funkcję. Warto też wiedzieć, że after() nie jest API czasu żądania: jego użycie nie robi z trasy strony dynamicznej, a na stronie statycznej callback wykona się podczas budowania lub rewalidacji.
Użycie w różnych kontekstach
after() działa w Server Components (także w generateMetadata), Server Actions, Route Handlers i w Proxy (dawnym Middleware).
W Route Handlers
Route Handler to plik route.ts eksportujący funkcję nazwaną metodą HTTP, np. export async function POST(request: Request), która czyta ciało przez await request.json(). Tak wygląda tworzenie zamówienia z efektami pobocznymi:
// app/api/orders/route.ts
import { after } from 'next/server';
import { sendEmail, updateInventory, notifyWarehouse } from '@/lib/services';
export async function POST(request: Request) {
const orderData = await request.json();
// Kluczowa operacja - tworzenie zamówienia
const order = await createOrder(orderData);
// Operacje poboczne - wykonane po odpowiedzi
after(async () => {
// Email potwierdzający
await sendEmail({
to: orderData.email,
subject: 'Potwierdzenie zamówienia',
template: 'order-confirmation',
data: order,
});
// Aktualizacja stanów magazynowych
await updateInventory(order.items);
// Powiadomienie magazynu
await notifyWarehouse(order);
// Logowanie do systemu audytu
await auditLog('order_created', { orderId: order.id });
});
// Odpowiedź natychmiastowa
return Response.json({
success: true,
orderId: order.id
});
}Klient dostaje orderId od razu, a email, magazyn i audyt obsługuje się w tle. W Route Handlers możesz nawet wywołać cookies() i headers() wewnątrz callbacku after().
W Server Components
W komponencie serwerowym after() śledzi wyświetlenie strony po jej wyrenderowaniu:
// app/products/[id]/page.tsx
import { after } from 'next/server';
import { trackPageView } from '@/lib/analytics';
export default async function ProductPage({ params }: { params: Promise<{ id: string }> }) {
const product = await getProduct((await params).id);
// Tracking po renderowaniu strony
after(async () => {
await trackPageView({
page: 'product',
productId: (await params).id,
productName: product.name,
category: product.category,
});
});
return (
<div className="product-page">
<h1>{product.name}</h1>
<p>{product.description}</p>
<span className="price">{product.price} zł</span>
</div>
);
}Uwaga na ograniczenie: w Server Components wewnątrz after() nie wolno wołać cookies() ani headers(), bo to rzuci błąd. Takie dane odczytaj wcześniej, w ciele komponentu, i przekaż do callbacku przez domknięcie.
W Server Actions
Server Action najpierw wykonuje operację kluczową i rewaliduje ścieżki, a resztę odkłada:
// app/actions/checkout.ts
'use server';
import { after } from 'next/server';
import { revalidatePath } from 'next/cache';
export async function completeCheckout(formData: FormData) {
const cartId = formData.get('cartId') as string;
// Kluczowa operacja
const order = await processPayment(cartId);
if (!order.success) {
return { error: 'Płatność nie powiodła się' };
}
// Rewalidacja ścieżek
revalidatePath('/cart');
revalidatePath('/orders');
// Operacje poboczne po odpowiedzi
after(async () => {
// Czyszczenie koszyka w tle
await clearCart(cartId);
// Generowanie faktury PDF
await generateInvoice(order.id);
// Integracje zewnętrzne
await syncWithERP(order);
await notifyShipping(order);
// Aktualizacja programu lojalnościowego
await updateLoyaltyPoints(order.userId, order.total);
});
return { success: true, orderId: order.id };
}Użytkownik widzi potwierdzenie płatności, zanim wygeneruje się faktura PDF. Rewalidacja zostaje przed after(), bo od niej zależy, co użytkownik zobaczy.
Wiele wywołań after()
Możesz użyć after() wielokrotnie - wszystkie callbacki zostaną wykonane:
import { after } from 'next/server';
export async function POST(request: Request) {
const data = await request.json();
const result = await processData(data);
// Logowanie
after(async () => {
await logger.info('Data processed', { id: result.id });
});
// Analytics
after(async () => {
await analytics.track('data_processed', {
processingTime: result.duration,
dataSize: data.length,
});
});
// Cleanup
after(async () => {
await cleanupTempFiles(result.tempPath);
});
return Response.json(result);
}Osobne callbacki porządkują kod według odpowiedzialności: logowanie, analityka, sprzątanie. Wywołania after() można też zagnieżdżać, np. w funkcjach pomocniczych.
Obsługa błędów w after()
Błędy w after() nie wpływają na odpowiedź, bo ta już poszła do klienta, ale powinny być obsługiwane:
import { after } from 'next/server';
export async function GET(request: Request) {
const data = await fetchData();
after(async () => {
try {
await riskyOperation();
} catch (error) {
// Loguj błąd, ale nie przerywaj
console.error('After callback failed:', error);
await errorReporting.capture(error);
}
});
return Response.json(data);
}Blok try/catch przechwytuje błąd i wysyła go do systemu raportowania, zamiast zostawić go bez śladu. Callback wykona się nawet wtedy, gdy odpowiedź zakończyła się błędem albo wywołaniem notFound() lub redirect().
Praktyczny przykład - System notyfikacji
Na koniec pełny Route Handler polubienia posta. Autoryzacja i zapis są kluczowe, a powiadomienia, statystyki i ranking mogą poczekać:
// app/api/posts/[id]/like/route.ts
import { after } from 'next/server';
import { getSession } from '@/lib/auth';
export async function POST(
request: Request,
{ params }: { params: Promise<{ id: string }> }
) {
const session = await getSession();
if (!session) {
return Response.json({ error: 'Unauthorized' }, { status: 401 });
}
// Kluczowa operacja - dodanie like'a
const like = await addLike((await params).id, session.userId);
// Wszystkie powiadomienia i side effects po odpowiedzi
after(async () => {
const post = await getPost((await params).id);
// Powiadomienie autora posta
if (post.authorId !== session.userId) {
await createNotification({
userId: post.authorId,
type: 'like',
message: `${session.user.name} polubił Twój post`,
link: `/posts/${(await params).id}`,
});
// Push notification
await sendPushNotification(post.authorId, {
title: 'Nowy like!',
body: `${session.user.name} polubił Twój post`,
});
}
// Aktualizacja statystyk
await incrementPostStats((await params).id, 'likes');
// Aktualizacja feed algorytmu
await updateFeedRanking((await params).id, 'engagement');
});
return Response.json({ liked: true, likeCount: like.count });
}Sprawdzenie sesji zostaje przed odpowiedzią, bo od niego zależy kod 401. Wszystko, co tylko informuje innych, trafia do after().
after() w specjalnych plikach tras
Ten sam model dotyczy specjalnych plików w katalogu app/, które Next.js traktuje jak Route Handlers: app/sitemap.js, app/robots.js, app/manifest.js i app/opengraph-image.js. Każdy z nich eksportuje funkcję domyślną, np. export default function sitemap():
// app/sitemap.ts
import type { MetadataRoute } from 'next';
export default function sitemap(): MetadataRoute.Sitemap {
return [{ url: 'https://quantum.example.com/', lastModified: new Date() }];
}Taki plik generuje /sitemap.xml bez ręcznego pisania XML-a. Podobny schemat ma webhook z zewnętrznego serwisu: endpoint, weryfikacja podpisu, przetworzenie zdarzenia, odpowiedź 200 OK. Ciężkie przetwarzanie możesz przenieść do after(), żeby szybko potwierdzić odbiór.
Kiedy używać after()?
Idealne przypadki użycia:
- Logowanie i audyt - zapisywanie działań użytkowników
- Analytics - śledzenie eventów i metryk
- Powiadomienia - wysyłanie emaili, push notifications
- Cleanup - czyszczenie plików tymczasowych
- Synchronizacja - aktualizacja zewnętrznych systemów
- Generowanie raportów - tworzenie plików w tle
Nie używaj dla:
- Walidacji - musi być przed odpowiedzią
- Autoryzacji - musi być przed odpowiedzią
- Danych potrzebnych w odpowiedzi - oczywiste!
- Operacji wymagających potwierdzenia - użytkownik nie zobaczy wyniku
Pamiętaj o limicie czasu: after() działa najwyżej tak długo, jak pozwala domyślny lub ustawiony w maxDuration limit trasy. Na platformach serverless Next.js korzysta z mechanizmu waitUntil, a eksport statyczny nie obsługuje after() wcale.
Podsumowanie
API after() w Next.js to potężne narzędzie optymalizacji:
- Szybsze odpowiedzi - operacje poboczne nie blokują użytkownika
- Lepsza UX - użytkownik widzi wynik natychmiast
- Czystszy kod - wyraźna separacja operacji kluczowych i pobocznych
- Niezawodność - błędy w after() nie psują odpowiedzi
Moja rada: przy każdym await w handlerze zapytaj, czy użytkownik naprawdę musi na nie czekać. Jeśli nie, przenieś je do after(). W następnej lekcji poznasz dyrektywę use cache, która przyspiesza z kolei samo pobieranie danych.
Zapamiętaj: w Metropolii Quantum odpowiedź leci do użytkownika z prędkością światła, a after() sprząta za nią w ciszy.
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. Do czego służy after() API w Next.js 16?
2. Który katalog w Next.js zawiera statyczne zasoby dostępne publicznie?
Zadania praktyczne w grze
- Układanie w pionie
Ułóż elementy w prawidłowej kolejności: app/ → sitemap.js → export default
- Układanie w pionie
Ułóż elementy w prawidłowej kolejności: Submit PR → Review code → Address feedba
- Układanie w pionie
Ułóż elementy w prawidłowej kolejności: app/ → robots.js → export default
- Klikanie w kolejności
Ułóż składnię route handlera API w Next.js App Router
- Układanie w pionie
Ułóż elementy w prawidłowej kolejności: Bump version → Update changelog → Tag re
- Układanie w pionie
Ułóż elementy w prawidłowej kolejności: app/ → opengraph-image.js → export defau
- Układanie w pionie
Ułóż kroki integracji płatności Stripe w Next.js
- Układanie w pionie
Ułóż ścieżkę i eksport pliku manifest.js
- Układanie w pionie
Ułóż kroki obsługi webhook z zewnętrznego serwisu
- Układanie w pionie
Ułóż elementy w prawidłowej kolejności: Server Component fetch → Client Componen
Zadania po tej lekcji
- Pytanieafter() API w Next.js 16
- Ułóż w kolejnościKolejność: app/ → sitemap.js → export default
- Ułóż w kolejnościKolejność: Submit PR → Review code → Address feedback
- Ułóż w kolejnościKolejność: app/ → robots.js → export default
- Kliknij w kolejnościSkładnia route handlera w Next.js
- Ułóż w kolejnościKolejność: Bump version → Update changelog → Tag release
- Ułóż w kolejnościKolejność: app/ → opengraph-image.js → export default
- Ułóż w kolejnościProces integracji Stripe Payments
- PytanieKatalog statycznych zasobów w Next.js
- Ułóż w kolejnościŚcieżka pliku manifest.js
- Ułóż w kolejnościProces webhookowej integracji
- Ułóż w kolejnościKolejność: Server Component fetch → Client Component mo