Kurs Next.js · Moduł 6: Formularze i Server Actions
Walidacja po stronie serwera z Server Actions
W tej lekcji8
Walidacja danych po stronie serwera jest nieodłącznym elementem bezpieczeństwa i integralności danych w aplikacjach webowych. W kontekscie Next.js, Server Actions - wprowadzone w Next.js 13 i ulepszone w kolejnych wersjach - oferują potężny mechanizm do wykonywania logiki po stronie serwera bezpośrednio z komponentów. W tym module omowimy, jak efektywnie implementować walidację z wykorzystaniem Server Actions.
Dlaczego potrzebujemy walidacji po stronie serwera?
Pomimo zalet walidacji po stronie klienta, walidacja serwerowa jest konieczna z kilku powodów:
- Bezpieczeństwo - kod JavaScript po stronie klienta może zostać zmodyfikowany lub pominięty
- Spójność danych - serwer jest ostateczną warstwą kontroli przed modyfikacją bazy danych
- Walidacja złożonych reguł biznesowych - niektore reguly mogą wymagać dostępu do danych na serwerze
- Progresywne ulepszanie - zapewnienie funkcjonalności nawet gdy JavaScript jest wyłączony
Podstawy Server Actions w Next.js
Server Actions to funkcje, które działają na serwerze, ale mogą być wywoływane bezpośrednio z kodu po stronie klienta. Trzeba zaznaczyć je dyrektywą 'use server' - albo na początku pliku (aby wszystkie funkcje w pliku były Server Actions), albo przed konkretnym eksportowanym wyrzęzeniem funkcji.
Podstawowa struktura Server Action
// app/actions.ts
'use server'; // Wszystkie funkcje eksportowane z tego pliku będą Server Actions
import { z } from 'zod';
// Schemat walidacji
const ContactSchema = z.object({
name: z.string().min(1, { message: 'Imię jest wymagane' }),
email: z.string().email({ message: 'Nieprawidłowy adres email' }),
message: z.string().min(10, { message: 'Wiadomość musi mieć co najmniej 10 znaków' })
});
export async function submitContactForm(formData: FormData) {
// Ekstrakcja danych z FormData
const name = formData.get('name');
const email = formData.get('email');
const message = formData.get('message');
// Walidacja danych za pomocą Zod
const result = ContactSchema.safeParse({ name, email, message });
if (!result.success) {
// Zwracamy błędy walidacji
return {
success: false,
errors: result.error.flatten().fieldErrors
};
}
// Przetwarzanie poprawnych danych
try {
// Tutaj byłby kod do zapisania wiadomości, wysyłki emaila itp.
console.log('Poprawne dane formularza:', result.data);
// Symulacja opóźnienia bazy danych
await new Promise(resolve => setTimeout(resolve, 1000));
return {
success: true,
message: 'Wiadomość została wysłana!'
};
} catch (error) {
console.error('Błąd podczas przetwarzania formularza:', error);
return {
success: false,
message: 'Wystąpił błąd podczas przetwarzania formularza. Spróbuj ponownie później.'
};
}
}Użycie Server Action w komponencie
// app/contact/page.tsx
'use client';
import { useRef, useState } from 'react';
import { submitContactForm } from '../actions';
type FormErrors = {
name?: string[];
email?: string[];
message?: string[];
};
export default function ContactPage() {
const formRef = useRef<HTMLFormElement>(null);
const [errors, setErrors] = useState<FormErrors>({});
const [loading, setLoading] = useState(false);
const [success, setSuccess] = useState(false);
async function handleSubmit(formData: FormData) {
setLoading(true);
setErrors({});
setSuccess(false);
const result = await submitContactForm(formData);
setLoading(false);
if (result.success) {
setSuccess(true);
formRef.current?.reset();
} else if (result.errors) {
setErrors(result.errors);
} else if (result.message) {
alert(result.message); // Alternatywnie można wyświetlić w UI
}
}
return (
<div className="max-w-md mx-auto p-6 bg-white rounded-lg shadow-md">
<h1 className="text-2xl font-bold mb-6">Kontakt</h1>
{success && (
<div className="mb-4 p-3 bg-green-100 text-green-700 rounded">
Dziękujemy za wiadomość! Odpowiemy najszybciej jak to możliwe.
</div>
)}
<form action={handleSubmit} ref={formRef} className="space-y-4">
<div>
<label htmlFor="name" className="block text-sm font-medium text-gray-700">
Imię i nazwisko
</label>
<input
type="text"
id="name"
name="name"
className={`mt-1 block w-full rounded-md ${errors.name ? 'border-red-500' : 'border-gray-300'}`}
/>
{errors.name && (
<p className="text-red-500 text-xs mt-1">{errors.name[0]}</p>
)}
</div>
<div>
<label htmlFor="email" className="block text-sm font-medium text-gray-700">
Email
</label>
<input
type="email"
id="email"
name="email"
className={`mt-1 block w-full rounded-md ${errors.email ? 'border-red-500' : 'border-gray-300'}`}
/>
{errors.email && (
<p className="text-red-500 text-xs mt-1">{errors.email[0]}</p>
)}
</div>
<div>
<label htmlFor="message" className="block text-sm font-medium text-gray-700">
Wiadomość
</label>
<textarea
id="message"
name="message"
rows={4}
className={`mt-1 block w-full rounded-md ${errors.message ? 'border-red-500' : 'border-gray-300'}`}
/>
{errors.message && (
<p className="text-red-500 text-xs mt-1">{errors.message[0]}</p>
)}
</div>
<button
type="submit"
disabled={loading}
className="w-full py-2 px-4 bg-blue-600 text-white rounded-md hover:bg-blue-700 disabled:opacity-50"
>
{loading ? 'Wysyłanie...' : 'Wyślij wiadomość'}
</button>
</form>
</div>
);
}W tym przykładzie:
- Formularz używa atrybutu
actionbezpośrednio z Server Action - Błędy walidacji są zwracane do komponentu i wyświetlane użytkownikowi
- Formularz może być zresetowany po pomyślnym wysłaniu
Zaawansowana walidacja z formularzami wielostopniowymi
Przykład walidacji w wielostopniowym formularzu z użyciem Server Actions:
// app/checkout/actions.ts
'use server';
import { z } from 'zod';
// Schemat walidacji dla danych osobowych
const PersonalDetailsSchema = z.object({
firstName: z.string().min(1, { message: 'Imię jest wymagane' }),
lastName: z.string().min(1, { message: 'Nazwisko jest wymagane' }),
email: z.string().email({ message: 'Nieprawidłowy adres email' }),
phone: z.string().regex(/^[0-9]{9}$/, { message: 'Numer telefonu musi mieć 9 cyfr' })
});
// Schemat walidacji dla adresu dostawy
const ShippingAddressSchema = z.object({
street: z.string().min(1, { message: 'Ulica jest wymagana' }),
city: z.string().min(1, { message: 'Miasto jest wymagane' }),
postalCode: z.string().regex(/^\d{2}-\d{3}$/, { message: 'Kod pocztowy musi mieć format XX-XXX' }),
country: z.string().min(1, { message: 'Kraj jest wymagany' })
});
// Schemat walidacji dla danych płatności
const PaymentDetailsSchema = z.object({
cardholderName: z.string().min(1, { message: 'Imię i nazwisko na karcie jest wymagane' }),
cardNumber: z.string().regex(/^[0-9]{16}$/, { message: 'Numer karty musi mieć 16 cyfr' }),
expiryDate: z.string().regex(/^(0[1-9]|1[0-2])\/[0-9]{2}$/, { message: 'Data ważności musi mieć format MM/RR' }),
cvv: z.string().regex(/^[0-9]{3}$/, { message: 'CVV musi składać się z 3 cyfr' })
});
// Funkcja walidująca dane osobowe
export async function validatePersonalDetails(formData: FormData) {
// Ekstrakcja danych
const data = {
firstName: formData.get('firstName'),
lastName: formData.get('lastName'),
email: formData.get('email'),
phone: formData.get('phone')
};
// Walidacja
const result = PersonalDetailsSchema.safeParse(data);
if (!result.success) {
return {
success: false,
errors: result.error.flatten().fieldErrors
};
}
// Opcjonalnie: zapisz dane w sesji
// await saveToSession('personalDetails', result.data);
return {
success: true,
data: result.data
};
}
// Funkcja walidująca adres dostawy
export async function validateShippingAddress(formData: FormData) {
const data = {
street: formData.get('street'),
city: formData.get('city'),
postalCode: formData.get('postalCode'),
country: formData.get('country')
};
const result = ShippingAddressSchema.safeParse(data);
if (!result.success) {
return {
success: false,
errors: result.error.flatten().fieldErrors
};
}
return {
success: true,
data: result.data
};
}
// Funkcja walidująca dane płatności
export async function validatePaymentDetails(formData: FormData) {
const data = {
cardholderName: formData.get('cardholderName'),
cardNumber: formData.get('cardNumber'),
expiryDate: formData.get('expiryDate'),
cvv: formData.get('cvv')
};
const result = PaymentDetailsSchema.safeParse(data);
if (!result.success) {
return {
success: false,
errors: result.error.flatten().fieldErrors
};
}
return {
success: true,
data: result.data
};
}
// Funkcja finalizująca zamówienie
export async function submitOrder(personalDetails: any, shippingAddress: any, paymentDetails: any) {
try {
// Tu byłaby kod do przetwarzania płatności i zapisania zamówienia
console.log('Przetwarzanie zamówienia:', { personalDetails, shippingAddress, paymentDetails });
// Symulacja opóźnienia
await new Promise(resolve => setTimeout(resolve, 1500));
// Generowanie numeru zamówienia
const orderNumber = Math.floor(100000 + Math.random() * 900000).toString();
return {
success: true,
orderNumber
};
} catch (error) {
console.error('Błąd podczas przetwarzania zamówienia:', error);
return {
success: false,
message: 'Wystąpił błąd podczas przetwarzania zamówienia. Spróbuj ponownie później.'
};
}
}I komponent klienta wykorzystujący te akcje:
// app/checkout/page.tsx
'use client';
import { useState } from 'react';
import { validatePersonalDetails, validateShippingAddress, validatePaymentDetails, submitOrder } from './actions';
// Typy błędów dla każdego kroku
type FormErrors = Record<string, string[]>;
export default function CheckoutPage() {
// Stany do śledzenia kroku, danych i błędów
const [currentStep, setCurrentStep] = useState(1);
const [loading, setLoading] = useState(false);
const [errors, setErrors] = useState<FormErrors>({});
const [formData, setFormData] = useState({
personalDetails: null,
shippingAddress: null,
paymentDetails: null
});
const [orderResult, setOrderResult] = useState<{ success: boolean; orderNumber?: string; message?: string } | null>(null);
// Funkcja do obsługi kroku 1 - dane osobowe
async function handlePersonalDetailsSubmit(formData: FormData) {
setLoading(true);
setErrors({});
const result = await validatePersonalDetails(formData);
setLoading(false);
if (result.success) {
setFormData(prev => ({ ...prev, personalDetails: result.data }));
setCurrentStep(2);
} else if (result.errors) {
setErrors(result.errors);
}
}
// Funkcja do obsługi kroku 2 - adres dostawy
async function handleShippingAddressSubmit(formData: FormData) {
setLoading(true);
setErrors({});
const result = await validateShippingAddress(formData);
setLoading(false);
if (result.success) {
setFormData(prev => ({ ...prev, shippingAddress: result.data }));
setCurrentStep(3);
} else if (result.errors) {
setErrors(result.errors);
}
}
// Funkcja do obsługi kroku 3 - dane płatności
async function handlePaymentDetailsSubmit(formData: FormData) {
setLoading(true);
setErrors({});
const result = await validatePaymentDetails(formData);
setLoading(false);
if (result.success) {
setFormData(prev => ({ ...prev, paymentDetails: result.data }));
// Po walidacji wszystkich kroków, wysyłamy zamówienie
await finalizeOrder(result.data);
} else if (result.errors) {
setErrors(result.errors);
}
}
// Finalizacja zamówienia
async function finalizeOrder(paymentDetails: any) {
setLoading(true);
const { personalDetails, shippingAddress } = formData;
const result = await submitOrder(personalDetails, shippingAddress, paymentDetails);
setLoading(false);
setOrderResult(result);
if (result.success) {
setCurrentStep(4); // Przejście do potwierdzenia
}
}
// Powrót do poprzedniego kroku
function goToPreviousStep() {
setCurrentStep(prev => Math.max(1, prev - 1));
setErrors({});
}
// Resetowanie formularza
function resetForm() {
setCurrentStep(1);
setFormData({
personalDetails: null,
shippingAddress: null,
paymentDetails: null
});
setErrors({});
setOrderResult(null);
}
return (
<div className="max-w-md mx-auto p-6 bg-white rounded-lg shadow-md">
<h1 className="text-2xl font-bold mb-6">Realizacja zamówienia</h1>
{/* Pasek postępu */}
<div className="mb-6">
<div className="flex justify-between">
{['Dane osobowe', 'Adres dostawy', 'Płatność', 'Potwierdzenie'].map((step, index) => (
<div key={index} className="flex flex-col items-center">
<div className={`h-8 w-8 rounded-full flex items-center justify-center text-sm ${currentStep > index + 1 ? 'bg-green-500 text-white' : currentStep === index + 1 ? 'bg-blue-600 text-white' : 'bg-gray-200 text-gray-600'}`}>
{currentStep > index + 1 ? '√' : index + 1}
</div>
<span className="text-xs mt-1">{step}</span>
</div>
))}
</div>
<div className="mt-2 h-2 bg-gray-200 rounded-full">
<div
className="h-full bg-blue-600 rounded-full transition-all duration-300"
style={{ width: `${Math.min(100, ((currentStep - 1) / 3) * 100)}%` }}
></div>
</div>
</div>
{/* Krok 1: Dane osobowe */}
{currentStep === 1 && (
<form action={handlePersonalDetailsSubmit} className="space-y-4">
<div>
<label htmlFor="firstName" className="block text-sm font-medium text-gray-700">Imię</label>
<input
type="text"
id="firstName"
name="firstName"
defaultValue={formData.personalDetails?.firstName || ''}
className={`mt-1 block w-full rounded-md ${errors.firstName ? 'border-red-500' : 'border-gray-300'}`}
/>
{errors.firstName && <p className="text-red-500 text-xs mt-1">{errors.firstName[0]}</p>}
</div>
<div>
<label htmlFor="lastName" className="block text-sm font-medium text-gray-700">Nazwisko</label>
<input
type="text"
id="lastName"
name="lastName"
defaultValue={formData.personalDetails?.lastName || ''}
className={`mt-1 block w-full rounded-md ${errors.lastName ? 'border-red-500' : 'border-gray-300'}`}
/>
{errors.lastName && <p className="text-red-500 text-xs mt-1">{errors.lastName[0]}</p>}
</div>
<div>
<label htmlFor="email" className="block text-sm font-medium text-gray-700">Email</label>
<input
type="email"
id="email"
name="email"
defaultValue={formData.personalDetails?.email || ''}
className={`mt-1 block w-full rounded-md ${errors.email ? 'border-red-500' : 'border-gray-300'}`}
/>
{errors.email && <p className="text-red-500 text-xs mt-1">{errors.email[0]}</p>}
</div>
<div>
<label htmlFor="phone" className="block text-sm font-medium text-gray-700">Telefon</label>
<input
type="tel"
id="phone"
name="phone"
defaultValue={formData.personalDetails?.phone || ''}
className={`mt-1 block w-full rounded-md ${errors.phone ? 'border-red-500' : 'border-gray-300'}`}
/>
{errors.phone && <p className="text-red-500 text-xs mt-1">{errors.phone[0]}</p>}
</div>
<button
type="submit"
disabled={loading}
className="w-full py-2 px-4 bg-blue-600 text-white rounded-md hover:bg-blue-700 disabled:opacity-50"
>
{loading ? 'Przetwarzanie...' : 'Dalej'}
</button>
</form>
)}
{/* Krok 2: Adres dostawy */}
{currentStep === 2 && (
<form action={handleShippingAddressSubmit} className="space-y-4">
<div>
<label htmlFor="street" className="block text-sm font-medium text-gray-700">Ulica i numer</label>
<input
type="text"
id="street"
name="street"
defaultValue={formData.shippingAddress?.street || ''}
className={`mt-1 block w-full rounded-md ${errors.street ? 'border-red-500' : 'border-gray-300'}`}
/>
{errors.street && <p className="text-red-500 text-xs mt-1">{errors.street[0]}</p>}
</div>
<div>
<label htmlFor="city" className="block text-sm font-medium text-gray-700">Miasto</label>
<input
type="text"
id="city"
name="city"
defaultValue={formData.shippingAddress?.city || ''}
className={`mt-1 block w-full rounded-md ${errors.city ? 'border-red-500' : 'border-gray-300'}`}
/>
{errors.city && <p className="text-red-500 text-xs mt-1">{errors.city[0]}</p>}
</div>
<div>
<label htmlFor="postalCode" className="block text-sm font-medium text-gray-700">Kod pocztowy</label>
<input
type="text"
id="postalCode"
name="postalCode"
defaultValue={formData.shippingAddress?.postalCode || ''}
className={`mt-1 block w-full rounded-md ${errors.postalCode ? 'border-red-500' : 'border-gray-300'}`}
/>
{errors.postalCode && <p className="text-red-500 text-xs mt-1">{errors.postalCode[0]}</p>}
</div>
<div>
<label htmlFor="country" className="block text-sm font-medium text-gray-700">Kraj</label>
<select
id="country"
name="country"
defaultValue={formData.shippingAddress?.country || ''}
className={`mt-1 block w-full rounded-md ${errors.country ? 'border-red-500' : 'border-gray-300'}`}
>
<option value="">Wybierz kraj</option>
<option value="Poland">Polska</option>
<option value="Germany">Niemcy</option>
<option value="UK">Wielka Brytania</option>
<option value="France">Francja</option>
</select>
{errors.country && <p className="text-red-500 text-xs mt-1">{errors.country[0]}</p>}
</div>
<div className="flex justify-between">
<button
type="button"
onClick={goToPreviousStep}
className="py-2 px-4 border border-gray-300 rounded-md hover:bg-gray-50"
>
Wstecz
</button>
<button
type="submit"
disabled={loading}
className="py-2 px-4 bg-blue-600 text-white rounded-md hover:bg-blue-700 disabled:opacity-50"
>
{loading ? 'Przetwarzanie...' : 'Dalej'}
</button>
</div>
</form>
)}
{/* Krok 3: Dane płatności */}
{currentStep === 3 && (
<form action={handlePaymentDetailsSubmit} className="space-y-4">
<div>
<label htmlFor="cardholderName" className="block text-sm font-medium text-gray-700">Imię i nazwisko na karcie</label>
<input
type="text"
id="cardholderName"
name="cardholderName"
className={`mt-1 block w-full rounded-md ${errors.cardholderName ? 'border-red-500' : 'border-gray-300'}`}
/>
{errors.cardholderName && <p className="text-red-500 text-xs mt-1">{errors.cardholderName[0]}</p>}
</div>
<div>
<label htmlFor="cardNumber" className="block text-sm font-medium text-gray-700">Numer karty</label>
<input
type="text"
id="cardNumber"
name="cardNumber"
className={`mt-1 block w-full rounded-md ${errors.cardNumber ? 'border-red-500' : 'border-gray-300'}`}
/>
{errors.cardNumber && <p className="text-red-500 text-xs mt-1">{errors.cardNumber[0]}</p>}
</div>
<div className="grid grid-cols-2 gap-4">
<div>
<label htmlFor="expiryDate" className="block text-sm font-medium text-gray-700">Data ważności</label>
<input
type="text"
id="expiryDate"
name="expiryDate"
className={`mt-1 block w-full rounded-md ${errors.expiryDate ? 'border-red-500' : 'border-gray-300'}`}
/>
{errors.expiryDate && <p className="text-red-500 text-xs mt-1">{errors.expiryDate[0]}</p>}
</div>
<div>
<label htmlFor="cvv" className="block text-sm font-medium text-gray-700">CVV</label>
<input
type="text"
id="cvv"
name="cvv"
className={`mt-1 block w-full rounded-md ${errors.cvv ? 'border-red-500' : 'border-gray-300'}`}
/>
{errors.cvv && <p className="text-red-500 text-xs mt-1">{errors.cvv[0]}</p>}
</div>
</div>
<div className="flex justify-between">
<button
type="button"
onClick={goToPreviousStep}
className="py-2 px-4 border border-gray-300 rounded-md hover:bg-gray-50"
>
Wstecz
</button>
<button
type="submit"
disabled={loading}
className="py-2 px-4 bg-blue-600 text-white rounded-md hover:bg-blue-700 disabled:opacity-50"
>
{loading ? 'Przetwarzanie płatności...' : 'Złóż zamówienie'}
</button>
</div>
</form>
)}
{/* Krok 4: Potwierdzenie */}
{currentStep === 4 && orderResult?.success && (
<div className="text-center py-8">
<div className="mb-4 w-16 h-16 rounded-full bg-green-100 flex items-center justify-center mx-auto">
<svg className="w-8 h-8 text-green-600" fill="none" viewBox="0 0 24 24" stroke="currentColor">
<path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M5 13l4 4L19 7" />
</svg>
</div>
<h2 className="text-2xl font-bold mb-2">Zamówienie przyjęte!</h2>
<p className="text-gray-600 mb-1">Dziękujemy za złożenie zamówienia.</p>
<p className="text-gray-600 mb-4">Numer zamówienia: <span className="font-medium">{orderResult.orderNumber}</span></p>
<p className="text-sm text-gray-500 mb-6">Szczegóły zamówienia wysłaliśmy na adres email: <br />{formData.personalDetails?.email}</p>
<button
onClick={resetForm}
className="inline-block py-2 px-4 bg-blue-600 text-white rounded-md hover:bg-blue-700"
>
Złóż nowe zamówienie
</button>
</div>
)}
{/* Komunikat błędu finalizacji */}
{currentStep === 3 && orderResult?.success === false && (
<div className="mt-4 p-3 bg-red-100 text-red-700 rounded">
{orderResult.message || 'Wystąpił błąd podczas przetwarzania zamówienia.'}
</div>
)}
</div>
);
}Użycie useFormStatus i useActionState
Next.js udostępnia hooki useFormStatus i useActionState, które zapewniają lepszą integracje z Server Actions w formularzach:
// app/contact/actions.ts
'use server';
import { z } from 'zod';
// Schemat walidacji
const ContactSchema = z.object({
name: z.string().min(1, { message: 'Imię jest wymagane' }),
email: z.string().email({ message: 'Nieprawidłowy adres email' }),
message: z.string().min(10, { message: 'Wiadomość musi mieć co najmniej 10 znaków' })
});
// Typ stanu formularza
type FormState = {
errors?: {
name?: string[];
email?: string[];
message?: string[];
};
message?: string;
success?: boolean;
};
// Server Action z formatem zwrotnym dla useActionState
export async function submitContactForm(prevState: FormState, formData: FormData): Promise<FormState> {
// Ekstrakcja danych
const name = formData.get('name');
const email = formData.get('email');
const message = formData.get('message');
// Walidacja
const result = ContactSchema.safeParse({ name, email, message });
if (!result.success) {
return {
errors: result.error.flatten().fieldErrors,
message: 'Popraw błędy w formularzu',
success: false
};
}
try {
// Zapis wiadomości do bazy, wysyłka emaila itp.
await new Promise(resolve => setTimeout(resolve, 1000));
// W rzeczywistej aplikacji, tu byłby kod do przetwarzania formularza
console.log('Wiadomość kontaktowa:', result.data);
return {
errors: {},
message: 'Wiadomość została wysłana!',
success: true
};
} catch (error) {
return {
errors: {},
message: 'Wystąpił błąd. Spróbuj ponownie później.',
success: false
};
}
}I odpowiadający komponent formularza:
// app/contact/page.tsx
'use client';
import { useActionState } from 'react';
import { useFormStatus } from 'react-dom';
import { submitContactForm } from './actions';
// Komponent przycisku z obsługą stanu formularza
function SubmitButton() {
// useFormStatus daje dostęp do stanu formularza, w tym pending
const { pending } = useFormStatus();
return (
<button
type="submit"
disabled={pending}
className="w-full py-2 px-4 bg-blue-600 text-white rounded-md hover:bg-blue-700 disabled:opacity-50"
>
{pending ? 'Wysyłanie...' : 'Wyślij wiadomość'}
</button>
);
}
export default function ContactPage() {
// Inicjalizacja stanu formularza
const initialState = { errors: {}, message: '', success: false };
// useActionState (łączy formularz z Server Action)
const [state, formAction] = useActionState(submitContactForm, initialState);
// Resetowanie formularza po udanym wysłaniu
const formRef = React.useRef<HTMLFormElement>(null);
React.useEffect(() => {
if (state.success && formRef.current) {
formRef.current.reset();
}
}, [state.success]);
return (
<div className="max-w-md mx-auto p-6 bg-white rounded-lg shadow-md">
<h1 className="text-2xl font-bold mb-6">Kontakt</h1>
{state.message && (
<div className={`mb-4 p-3 rounded ${state.success ? 'bg-green-100 text-green-700' : 'bg-red-100 text-red-700'}`}>
{state.message}
</div>
)}
<form ref={formRef} action={formAction} className="space-y-4">
<div>
<label htmlFor="name" className="block text-sm font-medium text-gray-700">
Imię i nazwisko
</label>
<input
type="text"
id="name"
name="name"
className={`mt-1 block w-full rounded-md ${state.errors?.name ? 'border-red-500' : 'border-gray-300'}`}
/>
{state.errors?.name && (
<p className="text-red-500 text-xs mt-1">{state.errors.name[0]}</p>
)}
</div>
<div>
<label htmlFor="email" className="block text-sm font-medium text-gray-700">
Email
</label>
<input
type="email"
id="email"
name="email"
className={`mt-1 block w-full rounded-md ${state.errors?.email ? 'border-red-500' : 'border-gray-300'}`}
/>
{state.errors?.email && (
<p className="text-red-500 text-xs mt-1">{state.errors.email[0]}</p>
)}
</div>
<div>
<label htmlFor="message" className="block text-sm font-medium text-gray-700">
Wiadomość
</label>
<textarea
id="message"
name="message"
rows={4}
className={`mt-1 block w-full rounded-md ${state.errors?.message ? 'border-red-500' : 'border-gray-300'}`}
/>
{state.errors?.message && (
<p className="text-red-500 text-xs mt-1">{state.errors.message[0]}</p>
)}
</div>
<SubmitButton />
</form>
</div>
);
}Kluczowe zalety tego podejścia:
- useFormStatus - pozwala na łatwe śledzenie stanu pending formularza
- useActionState - zapewnia automatyczne zarządzanie stanem między serwerem a klientem
- Progresywne ulepszanie - formularz działa nawet bez JavaScript
Walidacja z TypeScript i Zod
Zod doskonale integruje się z TypeScript, co pozwala na definiowanie schematów walidacji, które jednocześnie służą jako typy:
// app/lib/validationSchemas.ts
import { z } from 'zod';
// Schemat produktu
export const ProductSchema = z.object({
name: z.string().min(1, { message: 'Nazwa produktu jest wymagana' }),
price: z.coerce.number().min(0.01, { message: 'Cena musi być większa od 0' }),
description: z.string().min(10, { message: 'Opis musi mieć co najmniej 10 znaków' }),
category: z.enum(['electronics', 'clothing', 'food', 'books'], {
errorMap: () => ({ message: 'Wybierz poprawną kategorię' })
}),
quantity: z.coerce.number().int().min(0, { message: 'Ilość nie może być ujemna' }),
featured: z.boolean().default(false)
});
// Typ produktu inferowany ze schematu
export type Product = z.infer<typeof ProductSchema>;
// Schemat do edycji produktu (wszystkie pola opcjonalne)
export const ProductUpdateSchema = ProductSchema.partial();
export type ProductUpdate = z.infer<typeof ProductUpdateSchema>;Użycie w Server Action:
// app/products/actions.ts
'use server';
import { revalidatePath } from 'next/cache';
import { ProductSchema, ProductUpdateSchema, type Product } from '../lib/validationSchemas';
// Funkcja dodająca nowy produkt
export async function addProduct(formData: FormData) {
// Konwersja FormData do obiektu
const rawData = Object.fromEntries(formData.entries());
// Konwersja pola 'featured' na boolean (checkbox)
const productData = {
...rawData,
featured: formData.get('featured') === 'on'
};
// Walidacja danych
const validationResult = ProductSchema.safeParse(productData);
if (!validationResult.success) {
return {
success: false,
errors: validationResult.error.flatten().fieldErrors
};
}
try {
// W rzeczywistej aplikacji: zapisanie produktu w bazie danych
// const newProduct = await db.product.create({ data: validationResult.data });
console.log('Dodano nowy produkt:', validationResult.data);
// Rewalidacja ścieżki, aby odświeżyć cache
revalidatePath('/products');
return {
success: true,
message: 'Produkt został dodany pomyślnie!'
};
} catch (error) {
console.error('Błąd podczas dodawania produktu:', error);
return {
success: false,
message: 'Wystąpił błąd podczas dodawania produktu.'
};
}
}
// Funkcja aktualizująca produkt (wszystkie pola opcjonalne)
export async function updateProduct(id: string, formData: FormData) {
const rawData = Object.fromEntries(formData.entries());
// Usuwamy puste pola, które nie powinny być aktualizowane
for (const [key, value] of Object.entries(rawData)) {
if (value === '') {
delete rawData[key];
}
}
// Konwersja pola 'featured' na boolean (checkbox)
const productData = {
...rawData,
featured: formData.has('featured')
};
// Walidacja częściowej aktualizacji
const validationResult = ProductUpdateSchema.safeParse(productData);
if (!validationResult.success) {
return {
success: false,
errors: validationResult.error.flatten().fieldErrors
};
}
try {
// W rzeczywistej aplikacji: aktualizacja produktu w bazie danych
// const updatedProduct = await db.product.update({
// where: { id },
// data: validationResult.data
// });
console.log(`Zaktualizowano produkt ${id}:`, validationResult.data);
// Rewalidacja ścieżki, aby odświeżyć cache
revalidatePath(`/products/${id}`);
revalidatePath('/products');
return {
success: true,
message: 'Produkt został zaktualizowany pomyślnie!'
};
} catch (error) {
console.error('Błąd podczas aktualizacji produktu:', error);
return {
success: false,
message: 'Wystąpił błąd podczas aktualizacji produktu.'
};
}
}Bezpieczeństwo w Server Actions
Podczas implementacji walidacji w Server Actions, należy pamiętać o kilku kluczowych kwestiach bezpieczeństwa:
1. Ochrona przed CSRF (Cross-Site Request Forgery)
Next.js automatycznie zabezpiecza Server Actions przed atakami CSRF za pomocą tzw. "Action ID" i innych mechanizmów. Jednakże, dobrze jest mieć świadomość tej ochrony i stosować dodatkowe zabezpieczenia w krytycznych operacjach.
2. Rate Limiting
Dla wrażliwych operacji (np. logowanie, rejestracja) warto zastosować ograniczenie liczby żądań z jednego adresu IP:
'use server';
import { cookies } from 'next/headers';
// Prosta implementacja rate limitingu bazująca na cookies
export async function loginUser(formData: FormData) {
const cookieStore = await cookies();
const attemptsCookie = cookieStore.get('login_attempts');
// Sprawdzanie liczby prób logowania
const attempts = attemptsCookie ? parseInt(attemptsCookie.value, 10) : 0;
if (attempts >= 5) {
return {
success: false,
message: 'Zbyt wiele prób logowania. Spróbuj ponownie później.'
};
}
// Reszta logiki logowania...
// W przypadku nieudanego logowania zwiększamy licznik
if (!success) {
(await cookies()).set('login_attempts', String(attempts + 1), {
maxAge: 60 * 15, // 15 minut
httpOnly: true,
secure: process.env.NODE_ENV === 'production',
sameSite: 'strict'
});
} else {
// Resetowanie licznika po udanym logowaniu
(await cookies()).set('login_attempts', '0');
}
//
}3. Sanityzacja danych wejściowych
Zawsze czyść i waliduj dane wejściowe przed ich przetworzeniem:
'use server';
import { z } from 'zod';
import { sanitizeHtml } from 'some-html-sanitizer';
export async function addComment(formData: FormData) {
// Pobranie i wstępna sanityzacja
const rawComment = formData.get('comment')?.toString() || '';
const sanitizedComment = sanitizeHtml(rawComment, {
allowedTags: ['b', 'i', 'em', 'strong'],
allowedAttributes: {}
});
// Walidacja po sanityzacji
const commentSchema = z.string().min(5).max(1000);
const result = commentSchema.safeParse(sanitizedComment);
if (!result.success) {
return { success: false, errors: result.error.flatten().formErrors };
}
// Zapis do bazy...
}4. Autoryzacja w Server Actions
Zawsze sprawdzaj uprawnienia użytkownika przed wykonaniem operacji:
'use server';
import { getServerSession } from 'next-auth';
import { authOptions } from '../auth';
export async function deleteProduct(productId: string) {
// Pobranie sesji użytkownika
const session = await getServerSession(authOptions);
// Sprawdzenie czy użytkownik jest zalogowany
if (!session?.user) {
return {
success: false,
message: 'Musisz być zalogowany, aby wykonać tę operację.'
};
}
// Sprawdzenie dodatkowych uprawnień (np. roli administratora)
if (session.user.role !== 'admin') {
return {
success: false,
message: 'Nie masz uprawnień do wykonania tej operacji.'
};
}
// Wykonanie operacji...
}Dobre praktyki przy walidacji danych w Server Actions
Kombinacja walidacji klient+serwer - waliduj po stronie klienta dla lepszego UX, ale zawsze weryfikuj na serwerze
Spójne komunikaty błędów - używaj tych samych komunikatów po obu stronach
Progresywne ulepszanie - upewnij się, że formularze działają nawet bez JavaScript
Typowanie end-to-end - wykorzystaj inferowanie typów z Zod dla spójności między klientem a serwerem
Rewalidacja danych - używaj
revalidatePathlubrevalidateTagpo mutacjach, aby odświeżyć cacheStruktura błędów - utrzymuj spójny format odpowiedzi dla błędów
Minimalizacja stanu klienta - przechowuj jak najwięcej logiki na serwerze
Uwzględniaj dostępność - używaj odpowiednich opisów błędów i atrybutów ARIA
Podsumowanie
Server Actions w Next.js zapewniają potężny mechanizm do implementacji walidacji po stronie serwera, który łączy zalety bezpieczeństwa z dobrym doświadczeniem użytkownika:
- Bezpieczeństwo - dane są zawsze walidowane na serwerze, niezależnie od stanu JavaScript klienta
- Wydajność - brak konieczności tworzenia osobnych API endpoints
- Progresywne ulepszanie - formularze działają nawet bez JavaScript
- Spójność typów - możliwość dzielenia schematów walidacji między klientem a serwerem
Stosując opisane w tym module techniki i dobre praktyki, możesz tworzyć solidne, bezpieczne i przyjazne dla użytkownika formularze, które wykorzystują pełnię możliwości Next.js.
Kod do tej lekcji: App.tsx
import React, { useState } from 'react';
// Symulacja walidacji serwerowej z Server Actions w Next.js
type ServerState = {
status: 'idle' | 'pending' | 'success' | 'error';
errors: Record<string, string>;
message: string;
};
// Symulacja Server Action
async function simulateServerAction(formData: Record<string, string>): Promise<ServerState> {
// Symulacja opoznienia serwera
await new Promise(r => setTimeout(r, 1000));
const errors: Record<string, string> = {};
// Walidacja serwerowa - niezalezna od klienta
if (!formData.title || formData.title.length < 3) {
errors.title = 'Tytul musi miec minimum 3 znaki';
}
if (!formData.content || formData.content.length < 10) {
errors.content = 'Tresc musi miec minimum 10 znakow';
}
if (formData.title?.toLowerCase().includes('test')) {
errors.title = 'Serwer odrzucil: slowo "test" jest zabronione';
}
if (Object.keys(errors).length > 0) {
return { status: 'error', errors, message: 'Walidacja serwerowa nie powiodla sie' };
}
return { status: 'success', errors: {}, message: 'Dane zapisane na serwerze!' };
}
export default function ServerValidationDemo() {
const [values, setValues] = useState({ title: '', content: '' });
const [state, setState] = useState<ServerState>({ status: 'idle', errors: {}, message: '' });
const handleSubmit = async (e: React.FormEvent) => {
e.preventDefault();
setState({ status: 'pending', errors: {}, message: 'Walidacja na serwerze...' });
const result = await simulateServerAction(values);
setState(result);
};
const inputStyle: React.CSSProperties = {
width: '100%', padding: '10px', background: '#0d1117',
border: '1px solid #333', borderRadius: 6, color: '#e0e0e0',
fontFamily: 'monospace', fontSize: 13, boxSizing: 'border-box'
};
return (
<div style={{ background: '#0f0f23', minHeight: '100vh', padding: 20, color: '#e0e0e0', fontFamily: 'monospace' }}>
<h1 style={{ color: '#64ffda' }}>Server Actions - walidacja serwerowa</h1>
<p style={{ color: '#888', fontSize: 13, marginBottom: 16 }}>
Dane sa walidowane na serwerze - niezaleznie od JavaScript klienta.
Sprobuj uzyc slowa "test" w tytule!
</p>
<div style={{ background: '#0d1117', borderRadius: 8, padding: 12, marginBottom: 16 }}>
<pre style={{ color: '#ce93d8', fontSize: 11, margin: 0 }}>
{/* Przyklad Server Action */}
{'// app/actions.ts\n"use server"\n\nexport async function createPost(formData: FormData) {\n const title = formData.get("title");\n // walidacja na serwerze...\n}'}
</pre>
</div>
<form onSubmit={handleSubmit} style={{ maxWidth: 400 }}>
<div style={{ marginBottom: 12 }}>
<label style={{ color: '#64ffda', fontSize: 12, display: 'block', marginBottom: 4 }}>Tytul</label>
<input
value={values.title}
onChange={e => setValues(p => ({ ...p, title: e.target.value }))}
style={{ ...inputStyle, borderColor: state.errors.title ? '#f44336' : '#333' }}
/>
{state.errors.title && <div style={{ color: '#f44336', fontSize: 11, marginTop: 4 }}>{state.errors.title}</div>}
</div>
<div style={{ marginBottom: 12 }}>
<label style={{ color: '#64ffda', fontSize: 12, display: 'block', marginBottom: 4 }}>Tresc (min 10 znakow)</label>
<textarea
value={values.content}
onChange={e => setValues(p => ({ ...p, content: e.target.value }))}
rows={3}
style={{ ...inputStyle, resize: 'vertical', borderColor: state.errors.content ? '#f44336' : '#333' }}
/>
{state.errors.content && <div style={{ color: '#f44336', fontSize: 11, marginTop: 4 }}>{state.errors.content}</div>}
</div>
<button type="submit" disabled={state.status === 'pending'} style={{
background: state.status === 'pending' ? '#555' : '#ff9800',
color: '#fff', border: 'none', borderRadius: 6,
padding: '10px 20px', cursor: state.status === 'pending' ? 'wait' : 'pointer',
fontFamily: 'monospace', width: '100%'
}}>
{state.status === 'pending' ? 'Walidacja na serwerze...' : 'Wyslij (Server Action)'}
</button>
</form>
{state.message && state.status !== 'idle' && (
<div style={{
marginTop: 16, borderRadius: 8, padding: 12, maxWidth: 400,
background: state.status === 'success' ? '#1b5e20' : state.status === 'error' ? '#3e2723' : '#1a2744',
border: `1px solid ${state.status === 'success' ? '#4caf50' : state.status === 'error' ? '#f44336' : '#2196f3'}`,
}}>
<div style={{ color: state.status === 'success' ? '#4caf50' : state.status === 'error' ? '#f44336' : '#2196f3' }}>
{state.message}
</div>
</div>
)}
</div>
);
}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. Server Actions w Next.js pozwalają na:
2. Formik to:
To 2 z 4 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Edytor kodu
Utwórz formularz rejestracji używając React Hook Form z polami: username, email, password, confirmPassword
- Układanie w poziomie
Ułóż składnię input z register w React Hook Form
- Klikanie w kolejności
Ułóż składnię definicji schematu Zod
- Edytor kodu
Utwórz schema Zod dla formularza użytkownika z walidacją email, strong password, min/max lengths
- Edytor kodu
Utwórz Server Action do przetwarzania formularza kontaktowego z walidacją i wysyłaniem email
- Układanie w pionie
Ułóż elementy w prawidłowej kolejności: Install package → Import components → Cu
- Klikanie w kolejności
Ułóż składnię rejestracji inputa w React Hook Form
- Edytor kodu
Utwórz wieloetapowy formularz rejestracji z krokami: Personal Info, Account Details, Preferences
Zadania po tej lekcji
- PytanieServer Actions w Next.js pozwalają na:
- PytanieFormik to:
- Zadanie z kodemPraktyka: Utwórz formularz rejestracji używając React Hook
- Ułóż w kolejnościSkładnia input z register w React Hook Form
- Kliknij w kolejnościKolejność: const → schema → =
- Zadanie z kodemPraktyka: Utwórz schema Zod dla formularza użytkownika z
- PytanieProgressive Enhancement w formularzach oznacza:
- PytanieHook useActionState w React służy do:
- Zadanie z kodemPraktyka: Utwórz Server Action do przetwarzania formularza
- Ułóż w kolejnościKolejność: Install package → Import components → ...
- Kliknij w kolejnościSkładnia input z register
- Zadanie z kodemPraktyka: Utwórz wieloetapowy formularz rejestracji z