Kurs Next.js · Moduł 6: Formularze i Server Actions
Wielokrokowe formularze i przepływy
W tej lekcji7
Tworzenie złożonych, wieloetapowych formularzy to powszechne zadanie w aplikacjach webowych. Takie formularze są często wykorzystywane do procesów rejestracji, rezerwacji, zamówień czy konfiguracji produktów. W tym module przyjrzymy się różnym strategiom implementacji wielokrokowych formularzy w środowisku React i Next.js.
Dlaczego warto rozdzielać formularze na etapy?
Rozdzielenie długiego formularza na mniejsze kroki przynosi wiele korzyści:
- Lepsza doświadczenie użytkownika - krótsze formularze są mniej przytłaczające i zmniejszają ryzyko porzucenia
- Większa przejrzystość - użytkownicy mogą łatwiej skupić się na jednym aspekcie procesu naraz
- Progresywne zbieranie danych - możemy walidować każdy krok osobno i dostosowywać kolejne etapy na podstawie wcześniejszych odpowiedzi
- Organizacja logiczna - grupowanie powiązanych pól formularza poprawia strukturę i zrozumienie
- Możliwość zapisu częściowego - użytkownicy mogą zapisać swój postęp i wrócić później
Podstawowe podejścia do wieloetapowych formularzy
Istnieje kilka głównych podejść do implementacji wieloetapowych formularzy:
1. Podejście oparte na stanie komponentu
Najprostszym sposobem jest przechowywanie obecnego kroku i wszystkich danych formularza w stanie komponentu:
'use client';
import { useState, FormEvent } from 'react';
// Typy danych dla poszczególnych kroków
interface UserDetails {
firstName: string;
lastName: string;
email: string;
}
interface AddressDetails {
street: string;
city: string;
zipCode: string;
country: string;
}
interface PaymentDetails {
cardNumber: string;
expiryDate: string;
cvv: string;
}
// Połączone dane formularza
interface FormData {
user: UserDetails;
address: AddressDetails;
payment: PaymentDetails;
}
export default function MultiStepForm() {
// Stan aktualnego kroku
const [step, setStep] = useState(1);
// Stan danych formularza
const [formData, setFormData] = useState<FormData>({
user: {
firstName: '',
lastName: '',
email: ''
},
address: {
street: '',
city: '',
zipCode: '',
country: ''
},
payment: {
cardNumber: '',
expiryDate: '',
cvv: ''
}
});
// Stan walidacji
const [errors, setErrors] = useState<Record<string, string>>({});
// Obsługa zmiany pól formularza
function handleChange(e: React.ChangeEvent<HTMLInputElement>) {
const { name, value } = e.target;
// Określenie, do którego kroku należy pole
if (['firstName', 'lastName', 'email'].includes(name)) {
setFormData({
...formData,
user: {
...formData.user,
[name]: value
}
});
} else if (['street', 'city', 'zipCode', 'country'].includes(name)) {
setFormData({
...formData,
address: {
...formData.address,
[name]: value
}
});
} else if (['cardNumber', 'expiryDate', 'cvv'].includes(name)) {
setFormData({
...formData,
payment: {
...formData.payment,
[name]: value
}
});
}
// Usuwanie błędu po edycji pola
if (errors[name]) {
setErrors({
...errors,
[name]: ''
});
}
}
// Walidacja danych formularza dla każdego kroku
function validateStep(stepNumber: number): boolean {
const newErrors: Record<string, string> = {};
if (stepNumber === 1) {
// Walidacja danych użytkownika
if (!formData.user.firstName.trim()) {
newErrors.firstName = 'Imię jest wymagane';
}
if (!formData.user.lastName.trim()) {
newErrors.lastName = 'Nazwisko jest wymagane';
}
if (!formData.user.email.trim()) {
newErrors.email = 'Email jest wymagany';
} else if (!/^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}$/i.test(formData.user.email)) {
newErrors.email = 'Niepoprawny format adresu email';
}
} else if (stepNumber === 2) {
// Walidacja adresu
if (!formData.address.street.trim()) {
newErrors.street = 'Ulica jest wymagana';
}
if (!formData.address.city.trim()) {
newErrors.city = 'Miasto jest wymagane';
}
if (!formData.address.zipCode.trim()) {
newErrors.zipCode = 'Kod pocztowy jest wymagany';
}
if (!formData.address.country.trim()) {
newErrors.country = 'Kraj jest wymagany';
}
} else if (stepNumber === 3) {
// Walidacja płatności
if (!formData.payment.cardNumber.trim()) {
newErrors.cardNumber = 'Numer karty jest wymagany';
} else if (!/^\d{16}$/.test(formData.payment.cardNumber.replace(/\s/g, ''))) {
newErrors.cardNumber = 'Niepoprawny numer karty';
}
if (!formData.payment.expiryDate.trim()) {
newErrors.expiryDate = 'Data ważności jest wymagana';
}
if (!formData.payment.cvv.trim()) {
newErrors.cvv = 'Kod CVV jest wymagany';
} else if (!/^\d{3,4}$/.test(formData.payment.cvv)) {
newErrors.cvv = 'Niepoprawny kod CVV';
}
}
setErrors(newErrors);
return Object.keys(newErrors).length === 0;
}
// Przejście do następnego kroku
function handleNext() {
const isValid = validateStep(step);
if (isValid) {
setStep(step + 1);
}
}
// Powrót do poprzedniego kroku
function handlePrevious() {
setStep(step - 1);
}
// Przesłanie całego formularza
function handleSubmit(e: FormEvent) {
e.preventDefault();
const isValid = validateStep(step);
if (isValid) {
// Tutaj kod do wysłania danych do API
console.log('Przesyłanie danych formularza:', formData);
// Przykładowe wywołanie API (w rzeczywistej aplikacji)
// await fetch('/api/checkout', {
// method: 'POST',
// headers: { 'Content-Type': 'application/json' },
// body: JSON.stringify(formData)
// });
// Opcjonalnie: przekierowanie do strony potwierdzenia
// router.push('/checkout/success');
}
}
// Renderowanie odpowiedniego kroku
function renderStep() {
switch (step) {
case 1:
return (
<div className="space-y-4">
<h2 className="text-xl font-semibold">Dane osobowe</h2>
<div>
<label htmlFor="firstName" className="block text-sm font-medium text-gray-700">
Imię
</label>
<input
type="text"
id="firstName"
name="firstName"
value={formData.user.firstName}
onChange={handleChange}
className={`mt-1 block w-full rounded-md border ${
errors.firstName ? 'border-red-500' : 'border-gray-300'
} px-3 py-2`}
/>
{errors.firstName && (
<p className="mt-1 text-sm text-red-600">{errors.firstName}</p>
)}
</div>
<div>
<label htmlFor="lastName" className="block text-sm font-medium text-gray-700">
Nazwisko
</label>
<input
type="text"
id="lastName"
name="lastName"
value={formData.user.lastName}
onChange={handleChange}
className={`mt-1 block w-full rounded-md border ${
errors.lastName ? 'border-red-500' : 'border-gray-300'
} px-3 py-2`}
/>
{errors.lastName && (
<p className="mt-1 text-sm text-red-600">{errors.lastName}</p>
)}
</div>
<div>
<label htmlFor="email" className="block text-sm font-medium text-gray-700">
Email
</label>
<input
type="email"
id="email"
name="email"
value={formData.user.email}
onChange={handleChange}
className={`mt-1 block w-full rounded-md border ${
errors.email ? 'border-red-500' : 'border-gray-300'
} px-3 py-2`}
/>
{errors.email && (
<p className="mt-1 text-sm text-red-600">{errors.email}</p>
)}
</div>
<div className="flex justify-end">
<button
type="button"
onClick={handleNext}
className="px-4 py-2 bg-blue-500 text-white rounded-md hover:bg-blue-600"
>
Dalej
</button>
</div>
</div>
);
case 2:
return (
<div className="space-y-4">
<h2 className="text-xl font-semibold">Adres dostawy</h2>
<div>
<label htmlFor="street" className="block text-sm font-medium text-gray-700">
Ulica i numer
</label>
<input
type="text"
id="street"
name="street"
value={formData.address.street}
onChange={handleChange}
className={`mt-1 block w-full rounded-md border ${
errors.street ? 'border-red-500' : 'border-gray-300'
} px-3 py-2`}
/>
{errors.street && (
<p className="mt-1 text-sm text-red-600">{errors.street}</p>
)}
</div>
<div>
<label htmlFor="city" className="block text-sm font-medium text-gray-700">
Miasto
</label>
<input
type="text"
id="city"
name="city"
value={formData.address.city}
onChange={handleChange}
className={`mt-1 block w-full rounded-md border ${
errors.city ? 'border-red-500' : 'border-gray-300'
} px-3 py-2`}
/>
{errors.city && (
<p className="mt-1 text-sm text-red-600">{errors.city}</p>
)}
</div>
<div>
<label htmlFor="zipCode" className="block text-sm font-medium text-gray-700">
Kod pocztowy
</label>
<input
type="text"
id="zipCode"
name="zipCode"
value={formData.address.zipCode}
onChange={handleChange}
className={`mt-1 block w-full rounded-md border ${
errors.zipCode ? 'border-red-500' : 'border-gray-300'
} px-3 py-2`}
/>
{errors.zipCode && (
<p className="mt-1 text-sm text-red-600">{errors.zipCode}</p>
)}
</div>
<div>
<label htmlFor="country" className="block text-sm font-medium text-gray-700">
Kraj
</label>
<input
type="text"
id="country"
name="country"
value={formData.address.country}
onChange={handleChange}
className={`mt-1 block w-full rounded-md border ${
errors.country ? 'border-red-500' : 'border-gray-300'
} px-3 py-2`}
/>
{errors.country && (
<p className="mt-1 text-sm text-red-600">{errors.country}</p>
)}
</div>
<div className="flex justify-between">
<button
type="button"
onClick={handlePrevious}
className="px-4 py-2 bg-gray-200 text-gray-800 rounded-md hover:bg-gray-300"
>
Wstecz
</button>
<button
type="button"
onClick={handleNext}
className="px-4 py-2 bg-blue-500 text-white rounded-md hover:bg-blue-600"
>
Dalej
</button>
</div>
</div>
);
case 3:
return (
<div className="space-y-4">
<h2 className="text-xl font-semibold">Dane płatności</h2>
<div>
<label htmlFor="cardNumber" className="block text-sm font-medium text-gray-700">
Numer karty
</label>
<input
type="text"
id="cardNumber"
name="cardNumber"
value={formData.payment.cardNumber}
onChange={handleChange}
className={`mt-1 block w-full rounded-md border ${
errors.cardNumber ? 'border-red-500' : 'border-gray-300'
} px-3 py-2`}
/>
{errors.cardNumber && (
<p className="mt-1 text-sm text-red-600">{errors.cardNumber}</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"
value={formData.payment.expiryDate}
onChange={handleChange}
className={`mt-1 block w-full rounded-md border ${
errors.expiryDate ? 'border-red-500' : 'border-gray-300'
} px-3 py-2`}
/>
{errors.expiryDate && (
<p className="mt-1 text-sm text-red-600">{errors.expiryDate}</p>
)}
</div>
<div>
<label htmlFor="cvv" className="block text-sm font-medium text-gray-700">
CVV
</label>
<input
type="text"
id="cvv"
name="cvv"
value={formData.payment.cvv}
onChange={handleChange}
className={`mt-1 block w-full rounded-md border ${
errors.cvv ? 'border-red-500' : 'border-gray-300'
} px-3 py-2`}
/>
{errors.cvv && (
<p className="mt-1 text-sm text-red-600">{errors.cvv}</p>
)}
</div>
</div>
<div className="flex justify-between">
<button
type="button"
onClick={handlePrevious}
className="px-4 py-2 bg-gray-200 text-gray-800 rounded-md hover:bg-gray-300"
>
Wstecz
</button>
<button
type="submit"
onClick={handleSubmit}
className="px-4 py-2 bg-green-500 text-white rounded-md hover:bg-green-600"
>
Złóż zamówienie
</button>
</div>
</div>
);
default:
return null;
}
}
return (
<div className="max-w-2xl mx-auto px-4 py-8">
<div className="mb-8">
<div className="flex items-center justify-between mb-4">
<div className="flex items-center">
<div className={`w-8 h-8 rounded-full flex items-center justify-center ${
step >= 1 ? 'bg-blue-500 text-white' : 'bg-gray-200 text-gray-700'
}`}>
1
</div>
<div className={`h-1 w-12 ${step >= 2 ? 'bg-blue-500' : 'bg-gray-200'}`}></div>
</div>
<div className="flex items-center">
<div className={`w-8 h-8 rounded-full flex items-center justify-center ${
step >= 2 ? 'bg-blue-500 text-white' : 'bg-gray-200 text-gray-700'
}`}>
2
</div>
<div className={`h-1 w-12 ${step >= 3 ? 'bg-blue-500' : 'bg-gray-200'}`}></div>
</div>
<div className="flex items-center">
<div className={`w-8 h-8 rounded-full flex items-center justify-center ${
step >= 3 ? 'bg-blue-500 text-white' : 'bg-gray-200 text-gray-700'
}`}>
3
</div>
</div>
</div>
<div className="flex justify-between text-sm">
<span className={step >= 1 ? 'text-blue-500 font-medium' : ''}>Dane osobowe</span>
<span className={step >= 2 ? 'text-blue-500 font-medium' : ''}>Adres</span>
<span className={step >= 3 ? 'text-blue-500 font-medium' : ''}>Płatność</span>
</div>
</div>
<form className="bg-white shadow-md rounded-lg p-6">
{renderStep()}
</form>
</div>
);
}Główne cechy tego podejścia:
- Pojedynczy komponent zarządza całym procesem
- Stan zawiera wszystkie dane formularza i aktualny krok
- Przełączanie między krokami odbywa się przez zmianę stanu
- Walidacja jest wykonywana przed przejściem do następnego kroku
2. Podejście z komponentami dla każdego kroku
Alternatywnym podejściem jest stworzenie osobnych komponentów dla każdego kroku, co poprawia organizację kodu i możliwość ponownego użycia:
'use client';
import { useState } from 'react';
import { useRouter } from 'next/navigation';
// Typy dla danych formularza
interface UserFormData {
firstName: string;
lastName: string;
email: string;
}
interface AddressFormData {
street: string;
city: string;
zipCode: string;
country: string;
}
interface PaymentFormData {
cardNumber: string;
expiryDate: string;
cvv: string;
}
export type FormData = {
user: UserFormData;
address: AddressFormData;
payment: PaymentFormData;
}
// Komponent dla kroku 1: Dane użytkownika
interface UserFormProps {
data: UserFormData;
onSubmit: (data: UserFormData) => void;
}
function UserForm({ data, onSubmit }: UserFormProps) {
const [formData, setFormData] = useState(data);
const [errors, setErrors] = useState<Record<string, string>>({});
function handleChange(e: React.ChangeEvent<HTMLInputElement>) {
const { name, value } = e.target;
setFormData({ ...formData, [name]: value });
// Czyszczenie błędów
if (errors[name]) {
setErrors({ ...errors, [name]: '' });
}
}
function validate(): boolean {
const newErrors: Record<string, string> = {};
if (!formData.firstName.trim()) {
newErrors.firstName = 'Imię jest wymagane';
}
if (!formData.lastName.trim()) {
newErrors.lastName = 'Nazwisko jest wymagane';
}
if (!formData.email.trim()) {
newErrors.email = 'Email jest wymagany';
} else if (!/^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}$/i.test(formData.email)) {
newErrors.email = 'Niepoprawny format adresu email';
}
setErrors(newErrors);
return Object.keys(newErrors).length === 0;
}
function handleSubmit(e: React.FormEvent) {
e.preventDefault();
if (validate()) {
onSubmit(formData);
}
}
return (
<form onSubmit={handleSubmit} className="space-y-4">
<h2 className="text-xl font-semibold">Dane osobowe</h2>
<div>
<label htmlFor="firstName" className="block text-sm font-medium text-gray-700">
Imię
</label>
<input
type="text"
id="firstName"
name="firstName"
value={formData.firstName}
onChange={handleChange}
className={`mt-1 block w-full rounded-md border ${
errors.firstName ? 'border-red-500' : 'border-gray-300'
} px-3 py-2`}
/>
{errors.firstName && (
<p className="mt-1 text-sm text-red-600">{errors.firstName}</p>
)}
</div>
<div>
<label htmlFor="lastName" className="block text-sm font-medium text-gray-700">
Nazwisko
</label>
<input
type="text"
id="lastName"
name="lastName"
value={formData.lastName}
onChange={handleChange}
className={`mt-1 block w-full rounded-md border ${
errors.lastName ? 'border-red-500' : 'border-gray-300'
} px-3 py-2`}
/>
{errors.lastName && (
<p className="mt-1 text-sm text-red-600">{errors.lastName}</p>
)}
</div>
<div>
<label htmlFor="email" className="block text-sm font-medium text-gray-700">
Email
</label>
<input
type="email"
id="email"
name="email"
value={formData.email}
onChange={handleChange}
className={`mt-1 block w-full rounded-md border ${
errors.email ? 'border-red-500' : 'border-gray-300'
} px-3 py-2`}
/>
{errors.email && (
<p className="mt-1 text-sm text-red-600">{errors.email}</p>
)}
</div>
<div className="flex justify-end">
<button
type="submit"
className="px-4 py-2 bg-blue-500 text-white rounded-md hover:bg-blue-600"
>
Dalej
</button>
</div>
</form>
);
}
// Komponent dla kroku 2: Adres dostawy
interface AddressFormProps {
data: AddressFormData;
onSubmit: (data: AddressFormData) => void;
onBack: () => void;
}
function AddressForm({ data, onSubmit, onBack }: AddressFormProps) {
const [formData, setFormData] = useState(data);
const [errors, setErrors] = useState<Record<string, string>>({});
function handleChange(e: React.ChangeEvent<HTMLInputElement>) {
const { name, value } = e.target;
setFormData({ ...formData, [name]: value });
if (errors[name]) {
setErrors({ ...errors, [name]: '' });
}
}
function validate(): boolean {
const newErrors: Record<string, string> = {};
if (!formData.street.trim()) {
newErrors.street = 'Ulica jest wymagana';
}
if (!formData.city.trim()) {
newErrors.city = 'Miasto jest wymagane';
}
if (!formData.zipCode.trim()) {
newErrors.zipCode = 'Kod pocztowy jest wymagany';
}
if (!formData.country.trim()) {
newErrors.country = 'Kraj jest wymagany';
}
setErrors(newErrors);
return Object.keys(newErrors).length === 0;
}
function handleSubmit(e: React.FormEvent) {
e.preventDefault();
if (validate()) {
onSubmit(formData);
}
}
return (
<form onSubmit={handleSubmit} className="space-y-4">
<h2 className="text-xl font-semibold">Adres dostawy</h2>
<div>
<label htmlFor="street" className="block text-sm font-medium text-gray-700">
Ulica i numer
</label>
<input
type="text"
id="street"
name="street"
value={formData.street}
onChange={handleChange}
className={`mt-1 block w-full rounded-md border ${
errors.street ? 'border-red-500' : 'border-gray-300'
} px-3 py-2`}
/>
{errors.street && (
<p className="mt-1 text-sm text-red-600">{errors.street}</p>
)}
</div>
<div>
<label htmlFor="city" className="block text-sm font-medium text-gray-700">
Miasto
</label>
<input
type="text"
id="city"
name="city"
value={formData.city}
onChange={handleChange}
className={`mt-1 block w-full rounded-md border ${
errors.city ? 'border-red-500' : 'border-gray-300'
} px-3 py-2`}
/>
{errors.city && (
<p className="mt-1 text-sm text-red-600">{errors.city}</p>
)}
</div>
<div>
<label htmlFor="zipCode" className="block text-sm font-medium text-gray-700">
Kod pocztowy
</label>
<input
type="text"
id="zipCode"
name="zipCode"
value={formData.zipCode}
onChange={handleChange}
className={`mt-1 block w-full rounded-md border ${
errors.zipCode ? 'border-red-500' : 'border-gray-300'
} px-3 py-2`}
/>
{errors.zipCode && (
<p className="mt-1 text-sm text-red-600">{errors.zipCode}</p>
)}
</div>
<div>
<label htmlFor="country" className="block text-sm font-medium text-gray-700">
Kraj
</label>
<input
type="text"
id="country"
name="country"
value={formData.country}
onChange={handleChange}
className={`mt-1 block w-full rounded-md border ${
errors.country ? 'border-red-500' : 'border-gray-300'
} px-3 py-2`}
/>
{errors.country && (
<p className="mt-1 text-sm text-red-600">{errors.country}</p>
)}
</div>
<div className="flex justify-between">
<button
type="button"
onClick={onBack}
className="px-4 py-2 bg-gray-200 text-gray-800 rounded-md hover:bg-gray-300"
>
Wstecz
</button>
<button
type="submit"
className="px-4 py-2 bg-blue-500 text-white rounded-md hover:bg-blue-600"
>
Dalej
</button>
</div>
</form>
);
}
// Komponent dla kroku 3: Płatność
interface PaymentFormProps {
data: PaymentFormData;
onSubmit: (data: PaymentFormData) => void;
onBack: () => void;
}
function PaymentForm({ data, onSubmit, onBack }: PaymentFormProps) {
const [formData, setFormData] = useState(data);
const [errors, setErrors] = useState<Record<string, string>>({});
function handleChange(e: React.ChangeEvent<HTMLInputElement>) {
const { name, value } = e.target;
setFormData({ ...formData, [name]: value });
if (errors[name]) {
setErrors({ ...errors, [name]: '' });
}
}
function validate(): boolean {
const newErrors: Record<string, string> = {};
if (!formData.cardNumber.trim()) {
newErrors.cardNumber = 'Numer karty jest wymagany';
} else if (!/^\d{16}$/.test(formData.cardNumber.replace(/\s/g, ''))) {
newErrors.cardNumber = 'Niepoprawny numer karty';
}
if (!formData.expiryDate.trim()) {
newErrors.expiryDate = 'Data ważności jest wymagana';
}
if (!formData.cvv.trim()) {
newErrors.cvv = 'Kod CVV jest wymagany';
} else if (!/^\d{3,4}$/.test(formData.cvv)) {
newErrors.cvv = 'Niepoprawny kod CVV';
}
setErrors(newErrors);
return Object.keys(newErrors).length === 0;
}
function handleSubmit(e: React.FormEvent) {
e.preventDefault();
if (validate()) {
onSubmit(formData);
}
}
return (
<form onSubmit={handleSubmit} className="space-y-4">
<h2 className="text-xl font-semibold">Dane płatności</h2>
<div>
<label htmlFor="cardNumber" className="block text-sm font-medium text-gray-700">
Numer karty
</label>
<input
type="text"
id="cardNumber"
name="cardNumber"
value={formData.cardNumber}
onChange={handleChange}
className={`mt-1 block w-full rounded-md border ${
errors.cardNumber ? 'border-red-500' : 'border-gray-300'
} px-3 py-2`}
/>
{errors.cardNumber && (
<p className="mt-1 text-sm text-red-600">{errors.cardNumber}</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"
value={formData.expiryDate}
onChange={handleChange}
className={`mt-1 block w-full rounded-md border ${
errors.expiryDate ? 'border-red-500' : 'border-gray-300'
} px-3 py-2`}
/>
{errors.expiryDate && (
<p className="mt-1 text-sm text-red-600">{errors.expiryDate}</p>
)}
</div>
<div>
<label htmlFor="cvv" className="block text-sm font-medium text-gray-700">
CVV
</label>
<input
type="text"
id="cvv"
name="cvv"
value={formData.cvv}
onChange={handleChange}
className={`mt-1 block w-full rounded-md border ${
errors.cvv ? 'border-red-500' : 'border-gray-300'
} px-3 py-2`}
/>
{errors.cvv && (
<p className="mt-1 text-sm text-red-600">{errors.cvv}</p>
)}
</div>
</div>
<div className="flex justify-between">
<button
type="button"
onClick={onBack}
className="px-4 py-2 bg-gray-200 text-gray-800 rounded-md hover:bg-gray-300"
>
Wstecz
</button>
<button
type="submit"
className="px-4 py-2 bg-green-500 text-white rounded-md hover:bg-green-600"
>
Złóż zamówienie
</button>
</div>
</form>
);
}
// Komponent potwierdzenia
interface ConfirmationProps {
data: FormData;
onEdit: (step: number) => void;
}
function Confirmation({ data, onEdit }: ConfirmationProps) {
const router = useRouter();
async function handleConfirm() {
try {
// Symulacja wysyłki do API
console.log('Przesyłanie zamówienia:', data);
// Przykładowe wywołanie API (w rzeczywistej aplikacji)
// await fetch('/api/checkout', {
// method: 'POST',
// headers: { 'Content-Type': 'application/json' },
// body: JSON.stringify(data)
// });
// Przekierowanie do strony sukcesu
// router.push('/checkout/success');
// W przykładzie po prostu alertujemy sukces
alert('Zamówienie zostało złożone pomyślnie!');
} catch (error) {
console.error('Błąd podczas składania zamówienia:', error);
alert('Wystąpił błąd podczas składania zamówienia. Spróbuj ponownie.');
}
}
return (
<div className="space-y-6">
<h2 className="text-xl font-semibold">Potwierdzenie zamówienia</h2>
<div className="border border-gray-200 rounded-lg p-4 space-y-4">
<div>
<h3 className="font-medium text-gray-700 mb-2">Dane osobowe</h3>
<div className="bg-gray-50 p-3 rounded">
<p>{data.user.firstName} {data.user.lastName}</p>
<p>{data.user.email}</p>
</div>
<button
type="button"
onClick={() => onEdit(1)}
className="text-sm text-blue-500 mt-1"
>
Edytuj
</button>
</div>
<div>
<h3 className="font-medium text-gray-700 mb-2">Adres dostawy</h3>
<div className="bg-gray-50 p-3 rounded">
<p>{data.address.street}</p>
<p>{data.address.zipCode} {data.address.city}</p>
<p>{data.address.country}</p>
</div>
<button
type="button"
onClick={() => onEdit(2)}
className="text-sm text-blue-500 mt-1"
>
Edytuj
</button>
</div>
<div>
<h3 className="font-medium text-gray-700 mb-2">Sposób płatności</h3>
<div className="bg-gray-50 p-3 rounded">
<p>Karta: **** **** **** {data.payment.cardNumber.slice(-4)}</p>
<p>Ważna do: {data.payment.expiryDate}</p>
</div>
<button
type="button"
onClick={() => onEdit(3)}
className="text-sm text-blue-500 mt-1"
>
Edytuj
</button>
</div>
</div>
<div className="flex justify-center">
<button
type="button"
onClick={handleConfirm}
className="px-6 py-2 bg-green-500 text-white rounded-md hover:bg-green-600"
>
Potwierdź i złóż zamówienie
</button>
</div>
</div>
);
}
// Główny komponent formularza wielokrokowego
export default function MultiStepCheckout() {
const [step, setStep] = useState(1);
const [formData, setFormData] = useState<FormData>({
user: {
firstName: '',
lastName: '',
email: ''
},
address: {
street: '',
city: '',
zipCode: '',
country: ''
},
payment: {
cardNumber: '',
expiryDate: '',
cvv: ''
}
});
function handleUserSubmit(userData: UserFormData) {
setFormData({ ...formData, user: userData });
setStep(2);
}
function handleAddressSubmit(addressData: AddressFormData) {
setFormData({ ...formData, address: addressData });
setStep(3);
}
function handlePaymentSubmit(paymentData: PaymentFormData) {
setFormData({ ...formData, payment: paymentData });
setStep(4);
}
function renderProgressBar() {
return (
<div className="mb-8">
<div className="flex items-center justify-between mb-4">
{[1, 2, 3, 4].map((num) => (
<div key={num} className="flex items-center">
<div className={`w-8 h-8 rounded-full flex items-center justify-center ${
step >= num ? 'bg-blue-500 text-white' : 'bg-gray-200 text-gray-700'
}`}>
{num}
</div>
{num < 4 && (
<div className={`h-1 w-12 ${step > num ? 'bg-blue-500' : 'bg-gray-200'}`}></div>
)}
</div>
))}
</div>
<div className="flex justify-between text-sm">
<span className={step >= 1 ? 'text-blue-500 font-medium' : ''}>Dane osobowe</span>
<span className={step >= 2 ? 'text-blue-500 font-medium' : ''}>Adres</span>
<span className={step >= 3 ? 'text-blue-500 font-medium' : ''}>Płatność</span>
<span className={step >= 4 ? 'text-blue-500 font-medium' : ''}>Potwierdzenie</span>
</div>
</div>
);
}
function renderStep() {
switch (step) {
case 1:
return <UserForm data={formData.user} onSubmit={handleUserSubmit} />;
case 2:
return (
<AddressForm
data={formData.address}
onSubmit={handleAddressSubmit}
onBack={() => setStep(1)}
/>
);
case 3:
return (
<PaymentForm
data={formData.payment}
onSubmit={handlePaymentSubmit}
onBack={() => setStep(2)}
/>
);
case 4:
return <Confirmation data={formData} onEdit={setStep} />;
default:
return null;
}
}
return (
<div className="max-w-2xl mx-auto px-4 py-8">
{renderProgressBar()}
<div className="bg-white shadow-md rounded-lg p-6">
{renderStep()}
</div>
</div>
);
}Zalety tego podejścia:
- Lepsza organizacja kodu
- Każdy krok jest oddzielnym, niezależnym komponentem
- Łatwiejsza walidacja dla każdego kroku
- Możliwość ponownego użycia komponentów w innych miejscach
- Łatwiejsze testowanie poszczególnych etapów
3. Wielokrokowe formularze z Server Action w Next.js
Dla aplikacji Next.js możemy wykorzystać Server Actions do obsługi danych formularza:
// app/checkout/page.tsx
'use client';
import { useState } from 'react';
import { submitUserData, submitAddressData, submitPaymentData, completeOrder } from './actions';
// Podobne typy i komponenty formularzy jak w poprzednim przykładzie
//
export default function CheckoutPage() {
const [step, setStep] = useState(1);
const [userId, setUserId] = useState<string | null>(null);
const [formData, setFormData] = useState({
user: { /* dane użytkownika */ },
address: { /* adres */ },
payment: { /* płatność */ }
});
async function handleUserSubmit(userData: UserFormData) {
try {
// Zapisujemy dane użytkownika z użyciem Server Action
const result = await submitUserData(userData);
if (result.success) {
setUserId(result.userId);
setFormData({ ...formData, user: userData });
setStep(2);
} else {
// Obsługa błędów
alert(result.error || 'Wystąpił błąd. Spróbuj ponownie.');
}
} catch (error) {
console.error('Error submitting user data:', error);
alert('Wystąpił nieoczekiwany błąd. Spróbuj ponownie.');
}
}
async function handleAddressSubmit(addressData: AddressFormData) {
if (!userId) return;
try {
const result = await submitAddressData(userId, addressData);
if (result.success) {
setFormData({ ...formData, address: addressData });
setStep(3);
} else {
alert(result.error || 'Wystąpił błąd. Spróbuj ponownie.');
}
} catch (error) {
console.error('Error submitting address data:', error);
alert('Wystąpił nieoczekiwany błąd. Spróbuj ponownie.');
}
}
// Podobne funkcje dla pozostałych kroków
//
// Render komponentów formularza dla każdego kroku, podobnie jak wcześniej
//
}A oto przykładowa implementacja Server Actions:
// app/checkout/actions.ts
'use server';
import { z } from 'zod';
// Schematy walidacji dla formularzy
const UserSchema = 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: 'Niepoprawny adres email' })
});
const AddressSchema = z.object({
street: z.string().min(1, { message: 'Ulica jest wymagana' }),
city: z.string().min(1, { message: 'Miasto jest wymagane' }),
zipCode: z.string().min(1, { message: 'Kod pocztowy jest wymagany' }),
country: z.string().min(1, { message: 'Kraj jest wymagany' })
});
// Typy odpowiedzi z serwera
type ServerResponse<T> =
| { success: true; data: T }
| { success: false; error: string };
export async function submitUserData(formData: unknown): Promise<ServerResponse<{ userId: string }>> {
try {
// Walidacja danych
const validatedData = UserSchema.safeParse(formData);
if (!validatedData.success) {
return {
success: false,
error: validatedData.error.errors[0]?.message || 'Niepoprawne dane'
};
}
// W prawdziwej aplikacji: zapisanie danych w bazie
// const user = await db.user.create({ data: validatedData.data });
// Symulacja utworzenia użytkownika
console.log('Zapisano dane użytkownika:', validatedData.data);
return {
success: true,
data: { userId: 'user_123' }
};
} catch (error) {
console.error('Server error when submitting user data:', error);
return {
success: false,
error: 'Wystąpił błąd podczas przetwarzania danych'
};
}
}
export async function submitAddressData(
userId: string,
formData: unknown
): Promise<ServerResponse<{ addressId: string }>> {
try {
// Walidacja danych
const validatedData = AddressSchema.safeParse(formData);
if (!validatedData.success) {
return {
success: false,
error: validatedData.error.errors[0]?.message || 'Niepoprawne dane adresu'
};
}
// W prawdziwej aplikacji: zapisanie adresu w bazie
// const address = await db.address.create({
// data: { ...validatedData.data, userId }
// });
// Symulacja zapisania adresu
console.log('Zapisano adres dla użytkownika', userId, ':', validatedData.data);
return {
success: true,
data: { addressId: 'addr_456' }
};
} catch (error) {
console.error('Server error when submitting address data:', error);
return {
success: false,
error: 'Wystąpił błąd podczas przetwarzania adresu'
};
}
}
// Podobne funkcje dla płatności i finalizacji zamówienia
//Zalety tego podejścia:
- Walidacja i przetwarzanie danych na serwerze
- Możliwość stopniowego zapisywania danych w bazie
- Lepsza ochrona danych wrażliwych (np. dane płatności)
- Wsparcie dla progresywnego ulepszania
Zarządzanie stanem w wieloetapowych formularzach
W przypadku bardziej złożonych formularzy warto rozważyć użycie bibliotek do zarządzania stanem formularza:
Zarządzanie stanem z Formik lub React Hook Form
// Przykład z React Hook Form
import { useForm, FormProvider, useFormContext } from 'react-hook-form';
import { zodResolver } from '@hookform/resolvers/zod';
import { z } from 'zod';
// Schemat walidacji
const CheckoutSchema = z.object({
user: z.object({
firstName: z.string().min(1, 'Imię jest wymagane'),
lastName: z.string().min(1, 'Nazwisko jest wymagane'),
email: z.string().email('Niepoprawny adres email')
}),
address: z.object({
street: z.string().min(1, 'Ulica jest wymagana'),
city: z.string().min(1, 'Miasto jest wymagane'),
zipCode: z.string().min(1, 'Kod pocztowy jest wymagany'),
country: z.string().min(1, 'Kraj jest wymagany')
}),
payment: z.object({
cardNumber: z.string().refine(val => /^\d{16}$/.test(val.replace(/\s/g, '')), {
message: 'Niepoprawny numer karty'
}),
expiryDate: z.string().min(1, 'Data ważności jest wymagana'),
cvv: z.string().refine(val => /^\d{3,4}$/.test(val), {
message: 'Niepoprawny kod CVV'
})
})
});
type CheckoutData = z.infer<typeof CheckoutSchema>;
function UserFormStep() {
const { register, formState: { errors } } = useFormContext<CheckoutData>();
return (
<div className="space-y-4">
<h2 className="text-xl font-semibold">Dane osobowe</h2>
<div>
<label htmlFor="firstName" className="block text-sm font-medium">Imię</label>
<input
id="firstName"
{...register('user.firstName')}
className={`mt-1 block w-full rounded-md border ${
errors.user?.firstName ? 'border-red-500' : 'border-gray-300'
} px-3 py-2`}
/>
{errors.user?.firstName && (
<p className="mt-1 text-sm text-red-600">{errors.user.firstName.message}</p>
)}
</div>
{/* Pozostałe pola... */}
</div>
);
}
// Podobnie definiujemy pozostałe kroki formularza
//
export default function CheckoutForm() {
const [step, setStep] = useState(1);
const methods = useForm<CheckoutData>({
resolver: zodResolver(CheckoutSchema),
mode: 'onBlur',
defaultValues: {
user: { firstName: '', lastName: '', email: '' },
address: { street: '', city: '', zipCode: '', country: '' },
payment: { cardNumber: '', expiryDate: '', cvv: '' }
}
});
function onSubmit(data: CheckoutData) {
console.log('Przesyłanie danych:', data);
// Logika przesyłania danych do API
}
const nextStep = () => {
if (step < 3) {
setStep(step + 1);
} else {
methods.handleSubmit(onSubmit)();
}
};
const prevStep = () => setStep(step - 1);
return (
<FormProvider {...methods}>
<form onSubmit={methods.handleSubmit(onSubmit)}>
{/* Pasek postępu */}
{/* Renderowanie odpowiedniego kroku */}
{step === 1 && <UserFormStep />}
{step === 2 && <AddressFormStep />}
{step === 3 && <PaymentFormStep />}
{/* Przyciski nawigacyjne */}
<div className="mt-6 flex justify-between">
{step > 1 && (
<button
type="button"
onClick={prevStep}
className="px-4 py-2 bg-gray-200 text-gray-800 rounded-md"
>
Wstecz
</button>
)}
<button
type="button"
onClick={nextStep}
className={`px-4 py-2 ${
step === 3 ? 'bg-green-500 hover:bg-green-600' : 'bg-blue-500 hover:bg-blue-600'
} text-white rounded-md`}
>
{step === 3 ? 'Złóż zamówienie' : 'Dalej'}
</button>
</div>
</form>
</FormProvider>
);
}Zarządzanie stanem z użyciem kontekstu React
Dla bardzo złożonych formularzy może być korzystne użycie React Context API:
// context/CheckoutContext.tsx
import { createContext, useContext, useReducer, ReactNode } from 'react';
// Typy danych formularza
//
// Stan formularza
interface CheckoutState {
step: number;
user: UserFormData;
address: AddressFormData;
payment: PaymentFormData;
errors: Record<string, string>;
}
// Typy akcji
type CheckoutAction =
| { type: 'SET_STEP'; payload: number }
| { type: 'UPDATE_USER'; payload: Partial<UserFormData> }
| { type: 'UPDATE_ADDRESS'; payload: Partial<AddressFormData> }
| { type: 'UPDATE_PAYMENT'; payload: Partial<PaymentFormData> }
| { type: 'SET_ERRORS'; payload: Record<string, string> }
| { type: 'CLEAR_ERRORS' };
// Początkowy stan
const initialState: CheckoutState = {
step: 1,
user: { firstName: '', lastName: '', email: '' },
address: { street: '', city: '', zipCode: '', country: '' },
payment: { cardNumber: '', expiryDate: '', cvv: '' },
errors: {}
};
// Reducer
function checkoutReducer(state: CheckoutState, action: CheckoutAction): CheckoutState {
switch (action.type) {
case 'SET_STEP':
return { ...state, step: action.payload };
case 'UPDATE_USER':
return { ...state, user: { ...state.user, ...action.payload } };
case 'UPDATE_ADDRESS':
return { ...state, address: { ...state.address, ...action.payload } };
case 'UPDATE_PAYMENT':
return { ...state, payment: { ...state.payment, ...action.payload } };
case 'SET_ERRORS':
return { ...state, errors: action.payload };
case 'CLEAR_ERRORS':
return { ...state, errors: {} };
default:
return state;
}
}
// Typ kontekstu
interface CheckoutContextType {
state: CheckoutState;
nextStep: () => void;
prevStep: () => void;
updateUser: (data: Partial<UserFormData>) => void;
updateAddress: (data: Partial<AddressFormData>) => void;
updatePayment: (data: Partial<PaymentFormData>) => void;
validateStep: (step: number) => boolean;
submitOrder: () => Promise<void>;
}
// Kontekst
const CheckoutContext = createContext<CheckoutContextType | undefined>(undefined);
// Provider
export function CheckoutProvider({ children }: { children: ReactNode }) {
const [state, dispatch] = useReducer(checkoutReducer, initialState);
// Funkcje pomocnicze
const nextStep = () => {
if (validateStep(state.step)) {
dispatch({ type: 'SET_STEP', payload: state.step + 1 });
}
};
const prevStep = () => {
dispatch({ type: 'SET_STEP', payload: state.step - 1 });
};
const updateUser = (data: Partial<UserFormData>) => {
dispatch({ type: 'UPDATE_USER', payload: data });
};
const updateAddress = (data: Partial<AddressFormData>) => {
dispatch({ type: 'UPDATE_ADDRESS', payload: data });
};
const updatePayment = (data: Partial<PaymentFormData>) => {
dispatch({ type: 'UPDATE_PAYMENT', payload: data });
};
// Walidacja kroków
const validateStep = (step: number): boolean => {
// Logika walidacji...
return true; // Uproszczenie dla przykładu
};
// Przesyłanie zamówienia
const submitOrder = async () => {
if (validateStep(state.step)) {
try {
// Logika przesyłania danych
console.log('Przesyłanie danych:', state);
} catch (error) {
console.error('Error submitting order:', error);
}
}
};
return (
<CheckoutContext.Provider
value={{
state,
nextStep,
prevStep,
updateUser,
updateAddress,
updatePayment,
validateStep,
submitOrder
}}
>
{children}
</CheckoutContext.Provider>
);
}
// Hook do użycia kontekstu
export function useCheckout() {
const context = useContext(CheckoutContext);
if (context === undefined) {
throw new Error('useCheckout must be used within a CheckoutProvider');
}
return context;
}Zaawansowane techniki dla formularzy wieloetapowych
1. Warunkowe ścieżki formularza
Czasami chcemy, aby użytkownicy przechodzili różnymi ścieżkami formularza w zależności od ich wyborów:
// Przykładowa implementacja warunkowych ścieżek
function determineNextStep(currentStep: number, formData: FormData): number {
if (currentStep === 1) {
// Jeśli użytkownik wybrał wysyłkę do innego adresu, dodaj krok adresu dostawy
if (formData.shippingDifferent) {
return 2; // Krok adresu dostawy
} else {
return 3; // Pomiń krok adresu dostawy, przejdź do płatności
}
}
if (currentStep === 3) {
// Jeśli użytkownik wybrał płatność przelewem, pomiń krok danych karty
if (formData.paymentMethod === 'bankTransfer') {
return 5; // Przejdź do podsumowania
} else {
return 4; // Krok danych karty
}
}
// Domyślne przejście do następnego kroku
return currentStep + 1;
}
// Użycie w komponencie
function handleNext() {
const isValid = validateCurrentStep();
if (isValid) {
const nextStep = determineNextStep(step, formData);
setStep(nextStep);
}
}2. Zapisywanie i odtwarzanie stanu formularza
Dla długich formularzy warto umożliwić zapisanie postępu:
'use client';
import { useState, useEffect } from 'react';
// Zapisywanie stanu formularza
function saveFormState(data: FormData) {
localStorage.setItem('checkout_form', JSON.stringify(data));
localStorage.setItem('checkout_timestamp', Date.now().toString());
}
// Odtwarzanie stanu formularza
function getSavedFormState(): FormData | null {
const savedData = localStorage.getItem('checkout_form');
const timestamp = localStorage.getItem('checkout_timestamp');
if (!savedData || !timestamp) {
return null;
}
// Sprawdź, czy zapisane dane nie są za stare (np. 24 godziny)
const savedTime = parseInt(timestamp, 10);
const now = Date.now();
const oneDayMs = 24 * 60 * 60 * 1000;
if (now - savedTime > oneDayMs) {
// Dane są za stare, usuń je
localStorage.removeItem('checkout_form');
localStorage.removeItem('checkout_timestamp');
return null;
}
try {
return JSON.parse(savedData) as FormData;
} catch (e) {
return null;
}
}
export default function CheckoutForm() {
const [formData, setFormData] = useState<FormData>({
// Domyślny stan formularza
});
const [step, setStep] = useState(1);
const [hasRestoredState, setHasRestoredState] = useState(false);
// Próba odtworzenia stanu formularza przy pierwszym renderowaniu
useEffect(() => {
if (!hasRestoredState) {
const savedState = getSavedFormState();
if (savedState) {
setFormData(savedState);
setHasRestoredState(true);
// Opcjonalnie, zapytaj użytkownika, czy chce kontynuować od zapisanego miejsca
const wishToContinue = window.confirm(
'Znaleziono niekompletny formularz z poprzedniej sesji. Czy chcesz kontynuować od zapisanego miejsca?'
);
if (wishToContinue) {
// Możemy ustalić, na którym kroku użytkownik zakończył
// np. na podstawie tego, które dane są już wypełnione
if (savedState.payment.cardNumber) {
setStep(3);
} else if (savedState.address.street) {
setStep(2);
} else {
setStep(1);
}
} else {
// Użytkownik nie chce kontynuować, wyczyść zapisane dane
localStorage.removeItem('checkout_form');
localStorage.removeItem('checkout_timestamp');
setFormData({
// Zresetuj do domyślnego stanu
});
}
}
setHasRestoredState(true);
}
}, [hasRestoredState]);
// Zapisuj stan formularza przy zmianach
useEffect(() => {
if (hasRestoredState) {
saveFormState(formData);
}
}, [formData, hasRestoredState]);
// Reszta komponentu...
}3. Dynamiczne dodawanie i usuwanie pól formularza
W niektórych formularzach wieloetapowych użytkownicy mogą potrzebować dynamicznie dodawać lub usuwać elementy:
'use client';
import { useState } from 'react';
interface Item {
id: string;
name: string;
quantity: number;
}
function OrderItemsStep() {
const [items, setItems] = useState<Item[]>([
{ id: '1', name: '', quantity: 1 }
]);
const addItem = () => {
const newId = (parseInt(items[items.length - 1].id) + 1).toString();
setItems([...items, { id: newId, name: '', quantity: 1 }]);
};
const removeItem = (id: string) => {
// Nie usuwaj ostatniego elementu
if (items.length <= 1) return;
setItems(items.filter(item => item.id !== id));
};
const updateItem = (id: string, field: keyof Item, value: string | number) => {
setItems(items.map(item =>
item.id === id ? { ...item, [field]: value } : item
));
};
return (
<div className="space-y-4">
<h2 className="text-xl font-semibold">Elementy zamówienia</h2>
{items.map(item => (
<div key={item.id} className="flex items-center space-x-4 p-4 border rounded-md">
<div className="grow">
<label htmlFor={`item-name-${item.id}`} className="block text-sm font-medium">
Nazwa produktu
</label>
<input
id={`item-name-${item.id}`}
type="text"
value={item.name}
onChange={(e) => updateItem(item.id, 'name', e.target.value)}
className="mt-1 block w-full rounded-md border-gray-300 px-3 py-2"
/>
</div>
<div className="w-24">
<label htmlFor={`item-qty-${item.id}`} className="block text-sm font-medium">
Ilość
</label>
<input
id={`item-qty-${item.id}`}
type="number"
min="1"
value={item.quantity}
onChange={(e) => updateItem(item.id, 'quantity', parseInt(e.target.value))}
className="mt-1 block w-full rounded-md border-gray-300 px-3 py-2"
/>
</div>
<button
type="button"
onClick={() => removeItem(item.id)}
className="mt-6 px-2 py-2 bg-red-100 text-red-600 rounded-md hover:bg-red-200"
aria-label="Usuń element"
>
×
</button>
</div>
))}
<button
type="button"
onClick={addItem}
className="w-full mt-2 px-4 py-2 bg-gray-100 text-gray-700 rounded-md hover:bg-gray-200"
>
+ Dodaj więcej produktów
</button>
</div>
);
}Dobre praktyki dla formularzy wieloetapowych
Pokaż postęp - wskazuj użytkownikowi, w którym miejscu procesu się znajduje (pasek postępu, numeracja kroków)
Zachowaj dane - użytkownicy nie powinni tracić wprowadzonych danych w przypadku odświeżenia strony lub przypadkowego zamknięcia
Umożliw nawigację między krokami - pozwól użytkownikom wrócić do poprzednich kroków i edytować dane
Waliduj każdy krok - sprawdzaj poprawność danych przed przejściem do następnego kroku
Dostarczaj jasne komunikaty o błędach - informuj użytkownika dokładnie, co poszło nie tak
Zapewnij możliwość zapisania i powrotu później - zwłaszcza dla długich formularzy
Dostosuj kroki do urządzenia - na mniejszych ekranach rozważ jeszcze mniejsze kroki
Zapewnij podsumowanie przed finalnym przesłaniem - daj użytkownikom przegląd wszystkich wprowadzonych danych
Obsługuj wstecz/dalej w przeglądarce - dostosuj aplikację do działania przycisku wstecz/dalej przeglądarki
Testuj różne scenariusze - upewnij się, że formularz działa poprawnie zarówno w przypadku standardowego wypełniania, jak i w scenariuszach takich jak:
- Cofanie się do poprzednich kroków
- Odświeżanie strony
- Próba przesłania niepełnych danych
- Utrata połączenia internetowego
Drizzle ORM - lekka alternatywa dla Prisma
W Metropolii Quantum roku 2150, gdzie każdy cykl procesora ma znaczenie, developerzy często szukają narzędzi, które są zarówno potężne, jak i lekkie. Drizzle ORM to nowoczesna alternatywa dla Prisma, która oferuje type safety przy jednoczesnym zachowaniu bliskości do czystego SQL.
Drizzle vs Prisma - porównanie
Zarówno Drizzle jak i Prisma to type-safe ORM-y dla TypeScript, ale różnią się w filozofii i podejściu:
| Aspekt | Drizzle ORM | Prisma |
|---|---|---|
| Filozofia | SQL-like, bliżej metalu | Abstraction-first, przyjazne API |
| Rozmiar | ~20KB | ~600KB+ |
| Migracje | SQL lub TypeScript | Własny język DSL |
| Queries | Przypominają SQL | Własne API |
| Wydajność | Bardzo szybki | Dobry |
| Krzywa uczenia | Łagodna dla znających SQL | Łagodna dla początkujących |
| Type safety | Pełny | Pełny |
| Edge Runtime | Natywne wsparcie | Wymaga Data Proxy |
Dlaczego Drizzle jest lżejszy i bliższy SQL
Drizzle to "thin TypeScript layer" nad SQL, co oznacza, że:
- Minimalna abstrakcja - queries wyglądają jak SQL, więc łatwo je zoptymalizować
- Mały bundle size - kod Drizzle jest kompaktowy
- Zero runtime overhead - wszystkie typy są usuwane podczas kompilacji
- Pełna kontrola - możesz używać raw SQL gdy potrzebujesz
// Drizzle - przypomina SQL
const result = await db
.select()
.from(users)
.where(eq(users.email, 'user@example.com'))
.limit(1);
// Prisma - bardziej abstrakcyjne
const result = await prisma.user.findUnique({
where: { email: 'user@example.com' }
});Type-safe queries z Drizzle
Drizzle oferuje pełne wsparcie TypeScript, wykrywając błędy już na etapie pisania kodu:
Definicja schematu
// db/schema.ts
import { pgTable, serial, text, varchar, timestamp, integer, boolean } from 'drizzle-orm/pg-core';
import { relations } from 'drizzle-orm';
// Tabela użytkowników
export const users = pgTable('users', {
id: serial('id').primaryKey(),
name: varchar('name', { length: 255 }).notNull(),
email: varchar('email', { length: 255 }).notNull().unique(),
password: text('password').notNull(),
createdAt: timestamp('created_at').defaultNow().notNull(),
updatedAt: timestamp('updated_at').defaultNow().notNull()
});
// Tabela postów
export const posts = pgTable('posts', {
id: serial('id').primaryKey(),
title: varchar('title', { length: 255 }).notNull(),
content: text('content').notNull(),
published: boolean('published').default(false).notNull(),
authorId: integer('author_id')
.notNull()
.references(() => users.id, { onDelete: 'cascade' }),
createdAt: timestamp('created_at').defaultNow().notNull(),
updatedAt: timestamp('updated_at').defaultNow().notNull()
});
// Tabela komentarzy
export const comments = pgTable('comments', {
id: serial('id').primaryKey(),
content: text('content').notNull(),
postId: integer('post_id')
.notNull()
.references(() => posts.id, { onDelete: 'cascade' }),
authorId: integer('author_id')
.notNull()
.references(() => users.id, { onDelete: 'cascade' }),
createdAt: timestamp('created_at').defaultNow().notNull()
});
// Relacje między tabelami
export const usersRelations = relations(users, ({ many }) => ({
posts: many(posts),
comments: many(comments)
}));
export const postsRelations = relations(posts, ({ one, many }) => ({
author: one(users, {
fields: [posts.authorId],
references: [users.id]
}),
comments: many(comments)
}));
export const commentsRelations = relations(comments, ({ one }) => ({
post: one(posts, {
fields: [comments.postId],
references: [posts.id]
}),
author: one(users, {
fields: [comments.authorId],
references: [users.id]
})
}));
// Typy TypeScript automatycznie wygenerowane
export type User = typeof users.$inferSelect;
export type NewUser = typeof users.$inferInsert;
export type Post = typeof posts.$inferSelect;
export type NewPost = typeof posts.$inferInsert;
export type Comment = typeof comments.$inferSelect;
export type NewComment = typeof comments.$inferInsert;Konfiguracja połączenia
// db/index.ts
import { drizzle } from 'drizzle-orm/postgres-js';
import postgres from 'postgres';
import * as schema from './schema';
// Klient PostgreSQL
const connectionString = process.env.DATABASE_URL!;
const client = postgres(connectionString);
// Drizzle instance
export const db = drizzle(client, { schema });
// Dla Edge Runtime (Vercel, Cloudflare Workers)
// import { drizzle } from 'drizzle-orm/vercel-postgres';
// import { sql } from '@vercel/postgres';
// export const db = drizzle(sql, { schema });Type-safe queries
// app/actions/users.ts
'use server';
import { db } from '@/db';
import { users, posts } from '@/db/schema';
import { eq, and, or, like, desc, count } from 'drizzle-orm';
// SELECT - pobieranie danych
export async function getUser(id: number) {
const [user] = await db
.select()
.from(users)
.where(eq(users.id, id))
.limit(1);
return user;
}
// SELECT z wieloma warunkami
export async function searchUsers(query: string) {
return await db
.select({
id: users.id,
name: users.name,
email: users.email
})
.from(users)
.where(
or(
like(users.name, `%${query}%`),
like(users.email, `%${query}%`)
)
)
.limit(10);
}
// INSERT - tworzenie użytkownika
export async function createUser(data: {
name: string;
email: string;
password: string;
}) {
const [newUser] = await db
.insert(users)
.values(data)
.returning(); // PostgreSQL specific
return newUser;
}
// UPDATE - aktualizacja użytkownika
export async function updateUser(
id: number,
data: Partial<{ name: string; email: string }>
) {
const [updated] = await db
.update(users)
.set({
...data,
updatedAt: new Date()
})
.where(eq(users.id, id))
.returning();
return updated;
}
// DELETE - usuwanie użytkownika
export async function deleteUser(id: number) {
await db
.delete(users)
.where(eq(users.id, id));
}
// JOIN - pobieranie użytkownika z postami
export async function getUserWithPosts(userId: number) {
return await db.query.users.findFirst({
where: eq(users.id, userId),
with: {
posts: {
orderBy: [desc(posts.createdAt)],
limit: 10
}
}
});
}
// Agregacje
export async function getPostsCount(userId: number) {
const [result] = await db
.select({ count: count() })
.from(posts)
.where(eq(posts.authorId, userId));
return result.count;
}
// Transakcje
export async function createUserWithPost(
userData: { name: string; email: string; password: string },
postData: { title: string; content: string }
) {
return await db.transaction(async (tx) => {
// Utwórz użytkownika
const [user] = await tx
.insert(users)
.values(userData)
.returning();
// Utwórz post dla tego użytkownika
const [post] = await tx
.insert(posts)
.values({
...postData,
authorId: user.id,
published: false
})
.returning();
return { user, post };
});
}Zaawansowane queries
Relacyjne queries (Relational Queries API)
// Najprostszy sposób na JOIN-y
export async function getPostsWithAuthors() {
return await db.query.posts.findMany({
with: {
author: true,
comments: {
with: {
author: true
}
}
},
orderBy: [desc(posts.createdAt)],
limit: 20
});
}
// Częściowy select z relacjami
export async function getPostsPartial() {
return await db.query.posts.findMany({
columns: {
id: true,
title: true,
createdAt: true
},
with: {
author: {
columns: {
id: true,
name: true
}
}
}
});
}
// Filtrowanie w relacjach
export async function getPublishedPostsWithComments() {
return await db.query.posts.findMany({
where: eq(posts.published, true),
with: {
comments: {
where: (comments, { gte }) =>
gte(comments.createdAt, new Date('2024-01-01')),
limit: 5,
orderBy: [desc(comments.createdAt)]
}
}
});
}Raw SQL gdy potrzebujesz
import { sql } from 'drizzle-orm';
// Raw SQL dla zaawansowanych queries
export async function complexAnalytics() {
const result = await db.execute(sql`
SELECT
u.id,
u.name,
COUNT(DISTINCT p.id) as posts_count,
COUNT(DISTINCT c.id) as comments_count,
MAX(p.created_at) as last_post_date
FROM users u
LEFT JOIN posts p ON p.author_id = u.id
LEFT JOIN comments c ON c.author_id = u.id
WHERE u.created_at > NOW() - INTERVAL '30 days'
GROUP BY u.id, u.name
ORDER BY posts_count DESC
LIMIT 10
`);
return result.rows;
}
// Łączenie type-safe queries z raw SQL
export async function hybridQuery(minPosts: number) {
return await db
.select({
userId: users.id,
userName: users.name,
postsCount: sql<number>`COUNT(${posts.id})`
})
.from(users)
.leftJoin(posts, eq(posts.authorId, users.id))
.groupBy(users.id)
.having(sql`COUNT(${posts.id}) > ${minPosts}`);
}Migracje w Drizzle
Drizzle oferuje dwa sposoby na migracje:
1. Automatyczne generowanie SQL
// drizzle.config.ts
import type { Config } from 'drizzle-kit';
export default {
schema: './db/schema.ts',
out: './drizzle',
driver: 'pg',
dbCredentials: {
connectionString: process.env.DATABASE_URL!
}
} satisfies Config;# Generuj migracje
npx drizzle-kit generate:pg
# Wykonaj migracje
npx drizzle-kit push:pg
# Lub używając własnego skryptu
# db/migrate.ts
import { drizzle } from 'drizzle-orm/postgres-js';
import { migrate } from 'drizzle-orm/postgres-js/migrator';
import postgres from 'postgres';
const sql = postgres(process.env.DATABASE_URL!, { max: 1 });
const db = drizzle(sql);
await migrate(db, { migrationsFolder: './drizzle' });
await sql.end();2. Ręczne migracje SQL
-- drizzle/0001_initial.sql
CREATE TABLE IF NOT EXISTS "users" (
"id" serial PRIMARY KEY NOT NULL,
"name" varchar(255) NOT NULL,
"email" varchar(255) NOT NULL,
"password" text NOT NULL,
"created_at" timestamp DEFAULT now() NOT NULL,
"updated_at" timestamp DEFAULT now() NOT NULL,
CONSTRAINT "users_email_unique" UNIQUE("email")
);
CREATE TABLE IF NOT EXISTS "posts" (
"id" serial PRIMARY KEY NOT NULL,
"title" varchar(255) NOT NULL,
"content" text NOT NULL,
"published" boolean DEFAULT false NOT NULL,
"author_id" integer NOT NULL,
"created_at" timestamp DEFAULT now() NOT NULL,
"updated_at" timestamp DEFAULT now() NOT NULL,
CONSTRAINT "posts_author_id_users_id_fk"
FOREIGN KEY ("author_id") REFERENCES "users"("id")
ON DELETE cascade
);Integracja z Next.js App Router
// app/users/[id]/page.tsx
import { db } from '@/db';
import { users, posts } from '@/db/schema';
import { eq, desc } from 'drizzle-orm';
export default async function UserPage({
params
}: {
params: Promise<{ id: string }>
}) {
const userId = parseInt((await params).id);
// Query wykonywane w Server Component
const user = await db.query.users.findFirst({
where: eq(users.id, userId),
with: {
posts: {
orderBy: [desc(posts.createdAt)],
limit: 5
}
}
});
if (!user) {
return <div>Użytkownik nie znaleziony</div>;
}
return (
<div className="p-8">
<h1 className="text-3xl font-bold mb-4">{user.name}</h1>
<p className="text-gray-600 mb-8">{user.email}</p>
<h2 className="text-2xl font-semibold mb-4">Posty</h2>
<div className="space-y-4">
{user.posts.map(post => (
<article key={post.id} className="border p-4 rounded-lg">
<h3 className="text-xl font-bold">{post.title}</h3>
<p className="text-gray-600 mt-2">{post.content}</p>
<time className="text-sm text-gray-400 mt-2 block">
{post.createdAt.toLocaleDateString()}
</time>
</article>
))}
</div>
</div>
);
}
// app/actions/posts.ts
'use server';
import { db } from '@/db';
import { posts } from '@/db/schema';
import { revalidatePath } from 'next/cache';
export async function createPost(formData: FormData) {
const title = formData.get('title') as string;
const content = formData.get('content') as string;
const authorId = parseInt(formData.get('authorId') as string);
const [newPost] = await db
.insert(posts)
.values({
title,
content,
authorId,
published: false
})
.returning();
revalidatePath(`/users/${authorId}`);
return { success: true, post: newPost };
}Drizzle vs Prisma - kiedy wybrać?
Wybierz Drizzle gdy:
- Dobrze znasz SQL i chcesz mieć pełną kontrolę
- Zależy Ci na małym bundle size
- Budujesz edge applications
- Potrzebujesz maksymalnej wydajności
- Preferujesz minimalizm i prostotę
Wybierz Prisma gdy:
- Jesteś początkującym lub średnio-zaawansowanym
- Potrzebujesz doskonałej dokumentacji i ekosystemu
- Chcesz abstrakcję i nie martwić się o SQL
- Używasz Prisma Studio do zarządzania danymi
- Team jest większy i potrzebuje spójnych konwencji
Praktyczne zastosowanie
W Metropolii Quantum, gdzie aplikacje muszą być zarówno potężne jak i lekkie, Drizzle oferuje doskonałą alternatywę. Jego bliskość do SQL oznacza, że doświadczeni developerzy mogą łatwo optymalizować queries, podczas gdy pełne wsparcie TypeScript zapewnia bezpieczeństwo typów na każdym kroku.
// Przykład real-world: Dashboard z analytics
export async function getDashboardStats(userId: number) {
// Wszystko type-safe, przypomina SQL, szybkie
const stats = await db
.select({
totalPosts: count(posts.id),
publishedPosts: sql<number>`
COUNT(CASE WHEN ${posts.published} = true THEN 1 END)
`,
draftPosts: sql<number>`
COUNT(CASE WHEN ${posts.published} = false THEN 1 END)
`,
totalComments: count(comments.id)
})
.from(users)
.leftJoin(posts, eq(posts.authorId, users.id))
.leftJoin(comments, eq(comments.postId, posts.id))
.where(eq(users.id, userId))
.groupBy(users.id);
return stats[0];
}Podsumowanie
Wielokrokowe formularze to potężne narzędzie do zbierania złożonych danych od użytkowników w sposób przyjazny i zorganizowany. Istnieje wiele strategii ich implementacji, od prostych opartych o stan komponentu, przez modułowe podejście z oddzielnymi komponentami dla każdego kroku, po zaawansowane rozwiązania wykorzystujące kontekst React i biblioteki do zarządzania formularzami.
W React i Next.js mamy elastyczne możliwości implementacji takich formularzy, z dodatkowymi zaletami jakie oferują Server Actions w Next.js dla progresywnego ulepszania i bezpieczeństwa danych.
Kluczem do sukcesu jest wybór podejścia odpowiedniego do złożoności formularza i potrzeb aplikacji, jednocześnie zapewniając użytkownikom płynne i bezproblemowe doświadczenie.
Kod do tej lekcji: App.tsx
import React, { useState } from 'react';
type Step1Data = { firstName: string; lastName: string; email: string };
type Step2Data = { company: string; role: string; experience: string };
type Step3Data = { plan: string; newsletter: boolean };
type AllData = Step1Data & Step2Data & Step3Data;
const TOTAL_STEPS = 3;
function StepIndicator({ current, total }: { current: number; total: number }) {
return (
<div style={{ display: 'flex', alignItems: 'center', marginBottom: 24 }}>
{Array.from({ length: total }, (_, i) => (
<React.Fragment key={i}>
<div style={{
width: 32, height: 32, borderRadius: '50%', display: 'flex',
alignItems: 'center', justifyContent: 'center', fontWeight: 'bold',
fontSize: 13, fontFamily: 'monospace',
background: i + 1 < current ? '#4caf50' : i + 1 === current ? '#1a2744' : '#0d1117',
color: i + 1 < current ? '#fff' : i + 1 === current ? '#64ffda' : '#555',
border: i + 1 === current ? '2px solid #64ffda' : '2px solid transparent',
}}>
{i + 1 < current ? '✓' : i + 1}
</div>
{i < total - 1 && (
<div style={{ flex: 1, height: 2, background: i + 1 < current ? '#4caf50' : '#333', margin: '0 6px' }} />
)}
</React.Fragment>
))}
</div>
);
}
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', marginBottom: 12
};
function Step1({ data, onChange }: { data: Step1Data; onChange: (d: Partial<Step1Data>) => void }) {
return (
<div>
<h3 style={{ color: '#64ffda', margin: '0 0 12px' }}>Krok 1: Dane osobowe</h3>
<label style={{ color: '#64ffda', fontSize: 12, display: 'block', marginBottom: 4 }}>Imie *</label>
<input value={data.firstName} onChange={e => onChange({ firstName: e.target.value })} placeholder="Jan" style={inputStyle} />
<label style={{ color: '#64ffda', fontSize: 12, display: 'block', marginBottom: 4 }}>Nazwisko *</label>
<input value={data.lastName} onChange={e => onChange({ lastName: e.target.value })} placeholder="Kowalski" style={inputStyle} />
<label style={{ color: '#64ffda', fontSize: 12, display: 'block', marginBottom: 4 }}>Email *</label>
<input type="email" value={data.email} onChange={e => onChange({ email: e.target.value })} placeholder="jan@example.com" style={inputStyle} />
</div>
);
}
function Step2({ data, onChange }: { data: Step2Data; onChange: (d: Partial<Step2Data>) => void }) {
return (
<div>
<h3 style={{ color: '#64ffda', margin: '0 0 12px' }}>Krok 2: Informacje zawodowe</h3>
<label style={{ color: '#64ffda', fontSize: 12, display: 'block', marginBottom: 4 }}>Firma</label>
<input value={data.company} onChange={e => onChange({ company: e.target.value })} placeholder="Nazwa firmy" style={inputStyle} />
<label style={{ color: '#64ffda', fontSize: 12, display: 'block', marginBottom: 4 }}>Stanowisko *</label>
<select value={data.role} onChange={e => onChange({ role: e.target.value })} style={inputStyle}>
<option value="">-- Wybierz --</option>
<option value="frontend">Frontend Developer</option>
<option value="backend">Backend Developer</option>
<option value="fullstack">Fullstack Developer</option>
<option value="designer">UI/UX Designer</option>
</select>
<label style={{ color: '#64ffda', fontSize: 12, display: 'block', marginBottom: 4 }}>Doswiadczenie (lata) *</label>
<input type="number" value={data.experience} onChange={e => onChange({ experience: e.target.value })} placeholder="3" min="0" max="50" style={inputStyle} />
</div>
);
}
function Step3({ data, onChange }: { data: Step3Data; onChange: (d: Partial<Step3Data>) => void }) {
const plans = [
{ value: 'free', label: 'Free', desc: 'Podstawowy dostep' },
{ value: 'pro', label: 'Pro', desc: 'Pelny dostep + wsparcie' },
{ value: 'enterprise', label: 'Enterprise', desc: 'Dla zespolow + SLA' },
];
return (
<div>
<h3 style={{ color: '#64ffda', margin: '0 0 12px' }}>Krok 3: Wybierz plan</h3>
{plans.map(p => (
<label key={p.value} style={{
display: 'flex', alignItems: 'center', gap: 10, padding: 12, borderRadius: 6,
background: data.plan === p.value ? '#1a2744' : '#0d1117',
border: data.plan === p.value ? '1px solid #64ffda' : '1px solid #333',
cursor: 'pointer', marginBottom: 8
}}>
<input type="radio" name="plan" value={p.value} checked={data.plan === p.value}
onChange={() => onChange({ plan: p.value })} />
<div>
<strong style={{ color: data.plan === p.value ? '#64ffda' : '#e0e0e0' }}>{p.label}</strong>
<div style={{ color: '#888', fontSize: 11 }}>{p.desc}</div>
</div>
</label>
))}
<label style={{ display: 'flex', alignItems: 'center', gap: 8, marginTop: 12, cursor: 'pointer' }}>
<input type="checkbox" checked={data.newsletter} onChange={e => onChange({ newsletter: e.target.checked })} />
Chce otrzymywac newsletter
</label>
</div>
);
}
export default function MultiStepFormDemo() {
const [step, setStep] = useState(1);
const [data, setData] = useState<AllData>({
firstName: '', lastName: '', email: '',
company: '', role: '', experience: '',
plan: 'free', newsletter: false,
});
const [errors, setErrors] = useState<string[]>([]);
const [complete, setComplete] = useState(false);
const update = (partial: Partial<AllData>) => { setData(prev => ({ ...prev, ...partial })); setErrors([]); };
const validateStep = () => {
const errs: string[] = [];
if (step === 1) {
if (!data.firstName) errs.push('Imie jest wymagane');
if (!data.lastName) errs.push('Nazwisko jest wymagane');
if (!data.email) errs.push('Email jest wymagany');
} else if (step === 2) {
if (!data.role) errs.push('Wybierz stanowisko');
if (!data.experience) errs.push('Podaj doswiadczenie');
}
setErrors(errs);
return errs.length === 0;
};
const next = () => { if (validateStep()) setStep(s => Math.min(s + 1, TOTAL_STEPS)); };
const prev = () => { setErrors([]); setStep(s => Math.max(s - 1, 1)); };
const submit = (e: React.FormEvent) => { e.preventDefault(); if (validateStep()) setComplete(true); };
if (complete) {
return (
<div style={{ background: '#0f0f23', minHeight: '100vh', padding: 20, color: '#e0e0e0', fontFamily: 'monospace' }}>
<div style={{ maxWidth: 400, margin: '0 auto', textAlign: 'center' }}>
<div style={{ fontSize: 40, marginBottom: 12 }}>✅</div>
<h2 style={{ color: '#64ffda' }}>Rejestracja zakonczona!</h2>
<div style={{ background: '#0d1117', borderRadius: 8, padding: 12, marginTop: 12, textAlign: 'left', fontSize: 12 }}>
<p><strong>Imie:</strong> {data.firstName} {data.lastName}</p>
<p><strong>Email:</strong> {data.email}</p>
<p><strong>Firma:</strong> {data.company || 'Brak'}</p>
<p><strong>Stanowisko:</strong> {data.role}</p>
<p><strong>Doswiadczenie:</strong> {data.experience} lat</p>
<p><strong>Plan:</strong> {data.plan}</p>
<p><strong>Newsletter:</strong> {data.newsletter ? 'Tak' : 'Nie'}</p>
</div>
<button onClick={() => { setComplete(false); setStep(1); setData({ firstName: '', lastName: '', email: '', company: '', role: '', experience: '', plan: 'free', newsletter: false }); }}
style={{ marginTop: 12, padding: '8px 16px', borderRadius: 6, border: '1px solid #64ffda', background: 'transparent', color: '#64ffda', cursor: 'pointer', fontFamily: 'monospace' }}>
Nowa rejestracja
</button>
</div>
</div>
);
}
return (
<div style={{ background: '#0f0f23', minHeight: '100vh', padding: 20, color: '#e0e0e0', fontFamily: 'monospace' }}>
<h1 style={{ color: '#64ffda' }}>Formularz wielokrokowy</h1>
<p style={{ color: '#888', fontSize: 13, marginBottom: 16 }}>
3-krokowy proces rejestracji z walidacja kazdego kroku.
</p>
<div style={{ maxWidth: 400 }}>
<StepIndicator current={step} total={TOTAL_STEPS} />
{errors.length > 0 && (
<div role="alert" style={{ padding: 10, background: '#3e1010', borderRadius: 6, marginBottom: 12, border: '1px solid #f44336' }}>
{errors.map((err, i) => <p key={i} style={{ color: '#f44336', fontSize: 12, margin: '2px 0' }}>{err}</p>)}
</div>
)}
<form onSubmit={submit}>
{step === 1 && <Step1 data={data} onChange={update} />}
{step === 2 && <Step2 data={data} onChange={update} />}
{step === 3 && <Step3 data={data} onChange={update} />}
<div style={{ display: 'flex', gap: 10, marginTop: 16 }}>
{step > 1 && (
<button type="button" onClick={prev} style={{
flex: 1, padding: '10px', borderRadius: 6, border: '1px solid #444',
background: 'transparent', color: '#aaa', cursor: 'pointer', fontFamily: 'monospace'
}}>Wstecz</button>
)}
{step < TOTAL_STEPS ? (
<button type="button" onClick={next} style={{
flex: 1, padding: '10px', borderRadius: 6, border: 'none',
background: '#64ffda', color: '#0f0f23', fontWeight: 'bold', cursor: 'pointer', fontFamily: 'monospace'
}}>Dalej</button>
) : (
<button type="submit" style={{
flex: 1, padding: '10px', borderRadius: 6, border: 'none',
background: '#4caf50', color: '#fff', fontWeight: 'bold', cursor: 'pointer', fontFamily: 'monospace'
}}>Zarejestruj sie</button>
)}
</div>
</form>
</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. Form optimization dla performance obejmuje:
2. Optimistic updates w formularzach oznaczają:
To 2 z 6 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Układanie w poziomie
Ułóż składnię useForm z integracją zodResolver
- Układanie w pionie
Ułóż elementy w prawidłowej kolejności: Select file → Client validation → Upload
- Układanie w poziomie
Ułóż składnię komponentu ErrorMessage do wyświetlania błędów
- Układanie w pionie
Ułóż kolejność kroków w pipeline walidacji formularza
- Układanie w pionie
Ułóż kolejność kroków w wieloetapowym formularzu zamówienia
- Klikanie w kolejności
Ułóż składnię elementu form z action
- Klikanie w kolejności
Ułóż łańcuch walidacji Zod dla hasła
- Układanie w poziomie
Ułóż wzorzec dostępu do komunikatu błędu pola email w formState
- Układanie w pionie
Ułóż elementy w prawidłowej kolejności: Client-side validation → Form submission
- Układanie w poziomie
Ułóż składnię formularza z Server Action w Next.js
- Układanie w poziomie
Ułóż składnię tworzenia obiektu FormData z elementu formularza
- Edytor kodu
Stwórz kompletny security framework: 1. Authentication System - multi-provider OAuth z custom JWT implementation 2. Authorization Engine - RBAC/ABAC z fine-grained permissions 3. Session Management - secure session handling z auto-logout 4. Data Protection - end-to-end encryption z key management 5. Security Headers - CSP, HSTS, XSS protection configuration 6. Input Validation - advanced sanitization z custom validators 7. Rate Limiting - distributed rate limiting z Redis 8. Audit System - comprehensive logging z anomaly detection 9. Penetration Testing - automated security scanning 10. Compliance Tools - GDPR, CCPA compliance automation Użyj enterprise patterns: NextAuth.js, jose, bcryptjs, helmet, rate-limiter.
Zadania po tej lekcji
- PytanieForm optimization dla performance obejmuje:
- PytanieOptimistic updates w formularzach oznaczają:
- Ułóż w kolejnościSkładnia useForm z zodResolver
- PytanieCSRF protection w formularzach wymaga:
- Ułóż w kolejnościKolejność: Select file → Client validation → ...
- Ułóż w kolejnościSkładnia komponentu ErrorMessage
- Ułóż w kolejnościKolejność: pipeline walidacji formularza
- PytanieReact Final Form vs React Hook Form - główną różnicą jest:
- Ułóż w kolejnościKolejność: kroki wieloetapowego formularza
- Kliknij w kolejnościSkładnia elementu form z action
- Kliknij w kolejnościŁańcuch walidacji Zod dla hasła
- Ułóż w kolejnościDostęp do błędów formularza w React Hook Form
- Ułóż w kolejnościKolejność: Client-side validation → Form submission
- Ułóż w kolejnościSkładnia formularza z Server Action
- PytanieWalidacja formularzy w czasie rzeczywistym
- Ułóż w kolejnościTworzenie FormData z elementu formularza
- PytanieWarstwy bezpieczeństwa formularzy
- Zadanie z kodemSystem walidacji i bezpieczeństwa formularzy - krok po kroku
- Projekt do wysłaniaProjekt formularzy i Server Actions
- WideoPodsumowanie: Formularze i Server Actions w Next.js