Kurs Next.js · Moduł 6: Formularze i Server Actions

Wielokrokowe formularze i przepływy

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

  1. Lepsza doświadczenie użytkownika - krótsze formularze są mniej przytłaczające i zmniejszają ryzyko porzucenia
  2. Większa przejrzystość - użytkownicy mogą łatwiej skupić się na jednym aspekcie procesu naraz
  3. Progresywne zbieranie danych - możemy walidować każdy krok osobno i dostosowywać kolejne etapy na podstawie wcześniejszych odpowiedzi
  4. Organizacja logiczna - grupowanie powiązanych pól formularza poprawia strukturę i zrozumienie
  5. 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"
          >
            &times;
          </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

  1. Pokaż postęp - wskazuj użytkownikowi, w którym miejscu procesu się znajduje (pasek postępu, numeracja kroków)

  2. Zachowaj dane - użytkownicy nie powinni tracić wprowadzonych danych w przypadku odświeżenia strony lub przypadkowego zamknięcia

  3. Umożliw nawigację między krokami - pozwól użytkownikom wrócić do poprzednich kroków i edytować dane

  4. Waliduj każdy krok - sprawdzaj poprawność danych przed przejściem do następnego kroku

  5. Dostarczaj jasne komunikaty o błędach - informuj użytkownika dokładnie, co poszło nie tak

  6. Zapewnij możliwość zapisania i powrotu później - zwłaszcza dla długich formularzy

  7. Dostosuj kroki do urządzenia - na mniejszych ekranach rozważ jeszcze mniejsze kroki

  8. Zapewnij podsumowanie przed finalnym przesłaniem - daj użytkownikom przegląd wszystkich wprowadzonych danych

  9. Obsługuj wstecz/dalej w przeglądarce - dostosuj aplikację do działania przycisku wstecz/dalej przeglądarki

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

AspektDrizzle ORMPrisma
FilozofiaSQL-like, bliżej metaluAbstraction-first, przyjazne API
Rozmiar~20KB~600KB+
MigracjeSQL lub TypeScriptWłasny język DSL
QueriesPrzypominają SQLWłasne API
WydajnośćBardzo szybkiDobry
Krzywa uczeniaŁagodna dla znających SQLŁagodna dla początkujących
Type safetyPełnyPełny
Edge RuntimeNatywne wsparcieWymaga Data Proxy

Dlaczego Drizzle jest lżejszy i bliższy SQL

Drizzle to "thin TypeScript layer" nad SQL, co oznacza, że:

  1. Minimalna abstrakcja - queries wyglądają jak SQL, więc łatwo je zoptymalizować
  2. Mały bundle size - kod Drizzle jest kompaktowy
  3. Zero runtime overhead - wszystkie typy są usuwane podczas kompilacji
  4. 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. 1. Form optimization dla performance obejmuje:

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

  1. PytanieForm optimization dla performance obejmuje:
  2. PytanieOptimistic updates w formularzach oznaczają:
  3. Ułóż w kolejnościSkładnia useForm z zodResolver
  4. PytanieCSRF protection w formularzach wymaga:
  5. Ułóż w kolejnościKolejność: Select file → Client validation → ...
  6. Ułóż w kolejnościSkładnia komponentu ErrorMessage
  7. Ułóż w kolejnościKolejność: pipeline walidacji formularza
  8. PytanieReact Final Form vs React Hook Form - główną różnicą jest:
  9. Ułóż w kolejnościKolejność: kroki wieloetapowego formularza
  10. Kliknij w kolejnościSkładnia elementu form z action
  11. Kliknij w kolejnościŁańcuch walidacji Zod dla hasła
  12. Ułóż w kolejnościDostęp do błędów formularza w React Hook Form
  13. Ułóż w kolejnościKolejność: Client-side validation → Form submission
  14. Ułóż w kolejnościSkładnia formularza z Server Action
  15. PytanieWalidacja formularzy w czasie rzeczywistym
  16. Ułóż w kolejnościTworzenie FormData z elementu formularza
  17. PytanieWarstwy bezpieczeństwa formularzy
  18. Zadanie z kodemSystem walidacji i bezpieczeństwa formularzy - krok po kroku
  19. Projekt do wysłaniaProjekt formularzy i Server Actions
  20. WideoPodsumowanie: Formularze i Server Actions w Next.js

Przydatne artykuły