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

Walidacja po stronie serwera z Server Actions

19 min czytania ·
W tej lekcji8

Walidacja danych po stronie serwera jest nieodłącznym elementem bezpieczeństwa i integralności danych w aplikacjach webowych. W kontekscie Next.js, Server Actions - wprowadzone w Next.js 13 i ulepszone w kolejnych wersjach - oferują potężny mechanizm do wykonywania logiki po stronie serwera bezpośrednio z komponentów. W tym module omowimy, jak efektywnie implementować walidację z wykorzystaniem Server Actions.

Dlaczego potrzebujemy walidacji po stronie serwera?

Pomimo zalet walidacji po stronie klienta, walidacja serwerowa jest konieczna z kilku powodów:

  1. Bezpieczeństwo - kod JavaScript po stronie klienta może zostać zmodyfikowany lub pominięty
  2. Spójność danych - serwer jest ostateczną warstwą kontroli przed modyfikacją bazy danych
  3. Walidacja złożonych reguł biznesowych - niektore reguly mogą wymagać dostępu do danych na serwerze
  4. Progresywne ulepszanie - zapewnienie funkcjonalności nawet gdy JavaScript jest wyłączony

Podstawy Server Actions w Next.js

Server Actions to funkcje, które działają na serwerze, ale mogą być wywoływane bezpośrednio z kodu po stronie klienta. Trzeba zaznaczyć je dyrektywą 'use server' - albo na początku pliku (aby wszystkie funkcje w pliku były Server Actions), albo przed konkretnym eksportowanym wyrzęzeniem funkcji.

Podstawowa struktura Server Action

// app/actions.ts
'use server'; // Wszystkie funkcje eksportowane z tego pliku będą Server Actions

import { z } from 'zod';

// Schemat walidacji
const ContactSchema = z.object({
  name: z.string().min(1, { message: 'Imię jest wymagane' }),
  email: z.string().email({ message: 'Nieprawidłowy adres email' }),
  message: z.string().min(10, { message: 'Wiadomość musi mieć co najmniej 10 znaków' })
});

export async function submitContactForm(formData: FormData) {
  // Ekstrakcja danych z FormData
  const name = formData.get('name');
  const email = formData.get('email');
  const message = formData.get('message');

  // Walidacja danych za pomocą Zod
  const result = ContactSchema.safeParse({ name, email, message });

  if (!result.success) {
    // Zwracamy błędy walidacji
    return {
      success: false,
      errors: result.error.flatten().fieldErrors
    };
  }

  // Przetwarzanie poprawnych danych
  try {
    // Tutaj byłby kod do zapisania wiadomości, wysyłki emaila itp.
    console.log('Poprawne dane formularza:', result.data);

    // Symulacja opóźnienia bazy danych
    await new Promise(resolve => setTimeout(resolve, 1000));

    return {
      success: true,
      message: 'Wiadomość została wysłana!'
    };
  } catch (error) {
    console.error('Błąd podczas przetwarzania formularza:', error);
    return {
      success: false,
      message: 'Wystąpił błąd podczas przetwarzania formularza. Spróbuj ponownie później.'
    };
  }
}

Użycie Server Action w komponencie

// app/contact/page.tsx
'use client';

import { useRef, useState } from 'react';
import { submitContactForm } from '../actions';

type FormErrors = {
  name?: string[];
  email?: string[];
  message?: string[];
};

export default function ContactPage() {
  const formRef = useRef<HTMLFormElement>(null);
  const [errors, setErrors] = useState<FormErrors>({});
  const [loading, setLoading] = useState(false);
  const [success, setSuccess] = useState(false);

  async function handleSubmit(formData: FormData) {
    setLoading(true);
    setErrors({});
    setSuccess(false);

    const result = await submitContactForm(formData);

    setLoading(false);

    if (result.success) {
      setSuccess(true);
      formRef.current?.reset();
    } else if (result.errors) {
      setErrors(result.errors);
    } else if (result.message) {
      alert(result.message); // Alternatywnie można wyświetlić w UI
    }
  }

  return (
    <div className="max-w-md mx-auto p-6 bg-white rounded-lg shadow-md">
      <h1 className="text-2xl font-bold mb-6">Kontakt</h1>

      {success && (
        <div className="mb-4 p-3 bg-green-100 text-green-700 rounded">
          Dziękujemy za wiadomość! Odpowiemy najszybciej jak to możliwe.
        </div>
      )}

      <form action={handleSubmit} ref={formRef} className="space-y-4">
        <div>
          <label htmlFor="name" className="block text-sm font-medium text-gray-700">
            Imię i nazwisko
          </label>
          <input
            type="text"
            id="name"
            name="name"
            className={`mt-1 block w-full rounded-md ${errors.name ? 'border-red-500' : 'border-gray-300'}`}
          />
          {errors.name && (
            <p className="text-red-500 text-xs mt-1">{errors.name[0]}</p>
          )}
        </div>

        <div>
          <label htmlFor="email" className="block text-sm font-medium text-gray-700">
            Email
          </label>
          <input
            type="email"
            id="email"
            name="email"
            className={`mt-1 block w-full rounded-md ${errors.email ? 'border-red-500' : 'border-gray-300'}`}
          />
          {errors.email && (
            <p className="text-red-500 text-xs mt-1">{errors.email[0]}</p>
          )}
        </div>

        <div>
          <label htmlFor="message" className="block text-sm font-medium text-gray-700">
            Wiadomość
          </label>
          <textarea
            id="message"
            name="message"
            rows={4}
            className={`mt-1 block w-full rounded-md ${errors.message ? 'border-red-500' : 'border-gray-300'}`}
          />
          {errors.message && (
            <p className="text-red-500 text-xs mt-1">{errors.message[0]}</p>
          )}
        </div>

        <button
          type="submit"
          disabled={loading}
          className="w-full py-2 px-4 bg-blue-600 text-white rounded-md hover:bg-blue-700 disabled:opacity-50"
        >
          {loading ? 'Wysyłanie...' : 'Wyślij wiadomość'}
        </button>
      </form>
    </div>
  );
}

W tym przykładzie:

  1. Formularz używa atrybutu action bezpośrednio z Server Action
  2. Błędy walidacji są zwracane do komponentu i wyświetlane użytkownikowi
  3. Formularz może być zresetowany po pomyślnym wysłaniu

Zaawansowana walidacja z formularzami wielostopniowymi

Przykład walidacji w wielostopniowym formularzu z użyciem Server Actions:

// app/checkout/actions.ts
'use server';

import { z } from 'zod';

// Schemat walidacji dla danych osobowych
const PersonalDetailsSchema = z.object({
  firstName: z.string().min(1, { message: 'Imię jest wymagane' }),
  lastName: z.string().min(1, { message: 'Nazwisko jest wymagane' }),
  email: z.string().email({ message: 'Nieprawidłowy adres email' }),
  phone: z.string().regex(/^[0-9]{9}$/, { message: 'Numer telefonu musi mieć 9 cyfr' })
});

// Schemat walidacji dla adresu dostawy
const ShippingAddressSchema = z.object({
  street: z.string().min(1, { message: 'Ulica jest wymagana' }),
  city: z.string().min(1, { message: 'Miasto jest wymagane' }),
  postalCode: z.string().regex(/^\d{2}-\d{3}$/, { message: 'Kod pocztowy musi mieć format XX-XXX' }),
  country: z.string().min(1, { message: 'Kraj jest wymagany' })
});

// Schemat walidacji dla danych płatności
const PaymentDetailsSchema = z.object({
  cardholderName: z.string().min(1, { message: 'Imię i nazwisko na karcie jest wymagane' }),
  cardNumber: z.string().regex(/^[0-9]{16}$/, { message: 'Numer karty musi mieć 16 cyfr' }),
  expiryDate: z.string().regex(/^(0[1-9]|1[0-2])\/[0-9]{2}$/, { message: 'Data ważności musi mieć format MM/RR' }),
  cvv: z.string().regex(/^[0-9]{3}$/, { message: 'CVV musi składać się z 3 cyfr' })
});

// Funkcja walidująca dane osobowe
export async function validatePersonalDetails(formData: FormData) {
  // Ekstrakcja danych
  const data = {
    firstName: formData.get('firstName'),
    lastName: formData.get('lastName'),
    email: formData.get('email'),
    phone: formData.get('phone')
  };

  // Walidacja
  const result = PersonalDetailsSchema.safeParse(data);

  if (!result.success) {
    return {
      success: false,
      errors: result.error.flatten().fieldErrors
    };
  }

  // Opcjonalnie: zapisz dane w sesji
  // await saveToSession('personalDetails', result.data);

  return {
    success: true,
    data: result.data
  };
}

// Funkcja walidująca adres dostawy
export async function validateShippingAddress(formData: FormData) {
  const data = {
    street: formData.get('street'),
    city: formData.get('city'),
    postalCode: formData.get('postalCode'),
    country: formData.get('country')
  };

  const result = ShippingAddressSchema.safeParse(data);

  if (!result.success) {
    return {
      success: false,
      errors: result.error.flatten().fieldErrors
    };
  }

  return {
    success: true,
    data: result.data
  };
}

// Funkcja walidująca dane płatności
export async function validatePaymentDetails(formData: FormData) {
  const data = {
    cardholderName: formData.get('cardholderName'),
    cardNumber: formData.get('cardNumber'),
    expiryDate: formData.get('expiryDate'),
    cvv: formData.get('cvv')
  };

  const result = PaymentDetailsSchema.safeParse(data);

  if (!result.success) {
    return {
      success: false,
      errors: result.error.flatten().fieldErrors
    };
  }

  return {
    success: true,
    data: result.data
  };
}

// Funkcja finalizująca zamówienie
export async function submitOrder(personalDetails: any, shippingAddress: any, paymentDetails: any) {
  try {
    // Tu byłaby kod do przetwarzania płatności i zapisania zamówienia
    console.log('Przetwarzanie zamówienia:', { personalDetails, shippingAddress, paymentDetails });

    // Symulacja opóźnienia
    await new Promise(resolve => setTimeout(resolve, 1500));

    // Generowanie numeru zamówienia
    const orderNumber = Math.floor(100000 + Math.random() * 900000).toString();

    return {
      success: true,
      orderNumber
    };
  } catch (error) {
    console.error('Błąd podczas przetwarzania zamówienia:', error);
    return {
      success: false,
      message: 'Wystąpił błąd podczas przetwarzania zamówienia. Spróbuj ponownie później.'
    };
  }
}

I komponent klienta wykorzystujący te akcje:

// app/checkout/page.tsx
'use client';

import { useState } from 'react';
import { validatePersonalDetails, validateShippingAddress, validatePaymentDetails, submitOrder } from './actions';

// Typy błędów dla każdego kroku
type FormErrors = Record<string, string[]>;

export default function CheckoutPage() {
  // Stany do śledzenia kroku, danych i błędów
  const [currentStep, setCurrentStep] = useState(1);
  const [loading, setLoading] = useState(false);
  const [errors, setErrors] = useState<FormErrors>({});
  const [formData, setFormData] = useState({
    personalDetails: null,
    shippingAddress: null,
    paymentDetails: null
  });
  const [orderResult, setOrderResult] = useState<{ success: boolean; orderNumber?: string; message?: string } | null>(null);

  // Funkcja do obsługi kroku 1 - dane osobowe
  async function handlePersonalDetailsSubmit(formData: FormData) {
    setLoading(true);
    setErrors({});

    const result = await validatePersonalDetails(formData);

    setLoading(false);

    if (result.success) {
      setFormData(prev => ({ ...prev, personalDetails: result.data }));
      setCurrentStep(2);
    } else if (result.errors) {
      setErrors(result.errors);
    }
  }

  // Funkcja do obsługi kroku 2 - adres dostawy
  async function handleShippingAddressSubmit(formData: FormData) {
    setLoading(true);
    setErrors({});

    const result = await validateShippingAddress(formData);

    setLoading(false);

    if (result.success) {
      setFormData(prev => ({ ...prev, shippingAddress: result.data }));
      setCurrentStep(3);
    } else if (result.errors) {
      setErrors(result.errors);
    }
  }

  // Funkcja do obsługi kroku 3 - dane płatności
  async function handlePaymentDetailsSubmit(formData: FormData) {
    setLoading(true);
    setErrors({});

    const result = await validatePaymentDetails(formData);

    setLoading(false);

    if (result.success) {
      setFormData(prev => ({ ...prev, paymentDetails: result.data }));

      // Po walidacji wszystkich kroków, wysyłamy zamówienie
      await finalizeOrder(result.data);
    } else if (result.errors) {
      setErrors(result.errors);
    }
  }

  // Finalizacja zamówienia
  async function finalizeOrder(paymentDetails: any) {
    setLoading(true);

    const { personalDetails, shippingAddress } = formData;
    const result = await submitOrder(personalDetails, shippingAddress, paymentDetails);

    setLoading(false);
    setOrderResult(result);

    if (result.success) {
      setCurrentStep(4); // Przejście do potwierdzenia
    }
  }

  // Powrót do poprzedniego kroku
  function goToPreviousStep() {
    setCurrentStep(prev => Math.max(1, prev - 1));
    setErrors({});
  }

  // Resetowanie formularza
  function resetForm() {
    setCurrentStep(1);
    setFormData({
      personalDetails: null,
      shippingAddress: null,
      paymentDetails: null
    });
    setErrors({});
    setOrderResult(null);
  }

  return (
    <div className="max-w-md mx-auto p-6 bg-white rounded-lg shadow-md">
      <h1 className="text-2xl font-bold mb-6">Realizacja zamówienia</h1>

      {/* Pasek postępu */}
      <div className="mb-6">
        <div className="flex justify-between">
          {['Dane osobowe', 'Adres dostawy', 'Płatność', 'Potwierdzenie'].map((step, index) => (
            <div key={index} className="flex flex-col items-center">
              <div className={`h-8 w-8 rounded-full flex items-center justify-center text-sm ${currentStep > index + 1 ? 'bg-green-500 text-white' : currentStep === index + 1 ? 'bg-blue-600 text-white' : 'bg-gray-200 text-gray-600'}`}>
                {currentStep > index + 1 ? '√' : index + 1}
              </div>
              <span className="text-xs mt-1">{step}</span>
            </div>
          ))}
        </div>
        <div className="mt-2 h-2 bg-gray-200 rounded-full">
          <div
            className="h-full bg-blue-600 rounded-full transition-all duration-300"
            style={{ width: `${Math.min(100, ((currentStep - 1) / 3) * 100)}%` }}
          ></div>
        </div>
      </div>

      {/* Krok 1: Dane osobowe */}
      {currentStep === 1 && (
        <form action={handlePersonalDetailsSubmit} className="space-y-4">
          <div>
            <label htmlFor="firstName" className="block text-sm font-medium text-gray-700">Imię</label>
            <input
              type="text"
              id="firstName"
              name="firstName"
              defaultValue={formData.personalDetails?.firstName || ''}
              className={`mt-1 block w-full rounded-md ${errors.firstName ? 'border-red-500' : 'border-gray-300'}`}
            />
            {errors.firstName && <p className="text-red-500 text-xs mt-1">{errors.firstName[0]}</p>}
          </div>

          <div>
            <label htmlFor="lastName" className="block text-sm font-medium text-gray-700">Nazwisko</label>
            <input
              type="text"
              id="lastName"
              name="lastName"
              defaultValue={formData.personalDetails?.lastName || ''}
              className={`mt-1 block w-full rounded-md ${errors.lastName ? 'border-red-500' : 'border-gray-300'}`}
            />
            {errors.lastName && <p className="text-red-500 text-xs mt-1">{errors.lastName[0]}</p>}
          </div>

          <div>
            <label htmlFor="email" className="block text-sm font-medium text-gray-700">Email</label>
            <input
              type="email"
              id="email"
              name="email"
              defaultValue={formData.personalDetails?.email || ''}
              className={`mt-1 block w-full rounded-md ${errors.email ? 'border-red-500' : 'border-gray-300'}`}
            />
            {errors.email && <p className="text-red-500 text-xs mt-1">{errors.email[0]}</p>}
          </div>

          <div>
            <label htmlFor="phone" className="block text-sm font-medium text-gray-700">Telefon</label>
            <input
              type="tel"
              id="phone"
              name="phone"
              defaultValue={formData.personalDetails?.phone || ''}
              className={`mt-1 block w-full rounded-md ${errors.phone ? 'border-red-500' : 'border-gray-300'}`}
            />
            {errors.phone && <p className="text-red-500 text-xs mt-1">{errors.phone[0]}</p>}
          </div>

          <button
            type="submit"
            disabled={loading}
            className="w-full py-2 px-4 bg-blue-600 text-white rounded-md hover:bg-blue-700 disabled:opacity-50"
          >
            {loading ? 'Przetwarzanie...' : 'Dalej'}
          </button>
        </form>
      )}

      {/* Krok 2: Adres dostawy */}
      {currentStep === 2 && (
        <form action={handleShippingAddressSubmit} className="space-y-4">
          <div>
            <label htmlFor="street" className="block text-sm font-medium text-gray-700">Ulica i numer</label>
            <input
              type="text"
              id="street"
              name="street"
              defaultValue={formData.shippingAddress?.street || ''}
              className={`mt-1 block w-full rounded-md ${errors.street ? 'border-red-500' : 'border-gray-300'}`}
            />
            {errors.street && <p className="text-red-500 text-xs mt-1">{errors.street[0]}</p>}
          </div>

          <div>
            <label htmlFor="city" className="block text-sm font-medium text-gray-700">Miasto</label>
            <input
              type="text"
              id="city"
              name="city"
              defaultValue={formData.shippingAddress?.city || ''}
              className={`mt-1 block w-full rounded-md ${errors.city ? 'border-red-500' : 'border-gray-300'}`}
            />
            {errors.city && <p className="text-red-500 text-xs mt-1">{errors.city[0]}</p>}
          </div>

          <div>
            <label htmlFor="postalCode" className="block text-sm font-medium text-gray-700">Kod pocztowy</label>
            <input
              type="text"
              id="postalCode"
              name="postalCode"
              defaultValue={formData.shippingAddress?.postalCode || ''}
              className={`mt-1 block w-full rounded-md ${errors.postalCode ? 'border-red-500' : 'border-gray-300'}`}
            />
            {errors.postalCode && <p className="text-red-500 text-xs mt-1">{errors.postalCode[0]}</p>}
          </div>

          <div>
            <label htmlFor="country" className="block text-sm font-medium text-gray-700">Kraj</label>
            <select
              id="country"
              name="country"
              defaultValue={formData.shippingAddress?.country || ''}
              className={`mt-1 block w-full rounded-md ${errors.country ? 'border-red-500' : 'border-gray-300'}`}
            >
              <option value="">Wybierz kraj</option>
              <option value="Poland">Polska</option>
              <option value="Germany">Niemcy</option>
              <option value="UK">Wielka Brytania</option>
              <option value="France">Francja</option>
            </select>
            {errors.country && <p className="text-red-500 text-xs mt-1">{errors.country[0]}</p>}
          </div>

          <div className="flex justify-between">
            <button
              type="button"
              onClick={goToPreviousStep}
              className="py-2 px-4 border border-gray-300 rounded-md hover:bg-gray-50"
            >
              Wstecz
            </button>

            <button
              type="submit"
              disabled={loading}
              className="py-2 px-4 bg-blue-600 text-white rounded-md hover:bg-blue-700 disabled:opacity-50"
            >
              {loading ? 'Przetwarzanie...' : 'Dalej'}
            </button>
          </div>
        </form>
      )}

      {/* Krok 3: Dane płatności */}
      {currentStep === 3 && (
        <form action={handlePaymentDetailsSubmit} className="space-y-4">
          <div>
            <label htmlFor="cardholderName" className="block text-sm font-medium text-gray-700">Imię i nazwisko na karcie</label>
            <input
              type="text"
              id="cardholderName"
              name="cardholderName"
              className={`mt-1 block w-full rounded-md ${errors.cardholderName ? 'border-red-500' : 'border-gray-300'}`}
            />
            {errors.cardholderName && <p className="text-red-500 text-xs mt-1">{errors.cardholderName[0]}</p>}
          </div>

          <div>
            <label htmlFor="cardNumber" className="block text-sm font-medium text-gray-700">Numer karty</label>
            <input
              type="text"
              id="cardNumber"
              name="cardNumber"
              className={`mt-1 block w-full rounded-md ${errors.cardNumber ? 'border-red-500' : 'border-gray-300'}`}
            />
            {errors.cardNumber && <p className="text-red-500 text-xs mt-1">{errors.cardNumber[0]}</p>}
          </div>

          <div className="grid grid-cols-2 gap-4">
            <div>
              <label htmlFor="expiryDate" className="block text-sm font-medium text-gray-700">Data ważności</label>
              <input
                type="text"
                id="expiryDate"
                name="expiryDate"
                className={`mt-1 block w-full rounded-md ${errors.expiryDate ? 'border-red-500' : 'border-gray-300'}`}
              />
              {errors.expiryDate && <p className="text-red-500 text-xs mt-1">{errors.expiryDate[0]}</p>}
            </div>

            <div>
              <label htmlFor="cvv" className="block text-sm font-medium text-gray-700">CVV</label>
              <input
                type="text"
                id="cvv"
                name="cvv"
                className={`mt-1 block w-full rounded-md ${errors.cvv ? 'border-red-500' : 'border-gray-300'}`}
              />
              {errors.cvv && <p className="text-red-500 text-xs mt-1">{errors.cvv[0]}</p>}
            </div>
          </div>

          <div className="flex justify-between">
            <button
              type="button"
              onClick={goToPreviousStep}
              className="py-2 px-4 border border-gray-300 rounded-md hover:bg-gray-50"
            >
              Wstecz
            </button>

            <button
              type="submit"
              disabled={loading}
              className="py-2 px-4 bg-blue-600 text-white rounded-md hover:bg-blue-700 disabled:opacity-50"
            >
              {loading ? 'Przetwarzanie płatności...' : 'Złóż zamówienie'}
            </button>
          </div>
        </form>
      )}

      {/* Krok 4: Potwierdzenie */}
      {currentStep === 4 && orderResult?.success && (
        <div className="text-center py-8">
          <div className="mb-4 w-16 h-16 rounded-full bg-green-100 flex items-center justify-center mx-auto">
            <svg className="w-8 h-8 text-green-600" fill="none" viewBox="0 0 24 24" stroke="currentColor">
              <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M5 13l4 4L19 7" />
            </svg>
          </div>

          <h2 className="text-2xl font-bold mb-2">Zamówienie przyjęte!</h2>
          <p className="text-gray-600 mb-1">Dziękujemy za złożenie zamówienia.</p>
          <p className="text-gray-600 mb-4">Numer zamówienia: <span className="font-medium">{orderResult.orderNumber}</span></p>

          <p className="text-sm text-gray-500 mb-6">Szczegóły zamówienia wysłaliśmy na adres email: <br />{formData.personalDetails?.email}</p>

          <button
            onClick={resetForm}
            className="inline-block py-2 px-4 bg-blue-600 text-white rounded-md hover:bg-blue-700"
          >
            Złóż nowe zamówienie
          </button>
        </div>
      )}

      {/* Komunikat błędu finalizacji */}
      {currentStep === 3 && orderResult?.success === false && (
        <div className="mt-4 p-3 bg-red-100 text-red-700 rounded">
          {orderResult.message || 'Wystąpił błąd podczas przetwarzania zamówienia.'}
        </div>
      )}
    </div>
  );
}

Użycie useFormStatus i useActionState

Next.js udostępnia hooki useFormStatus i useActionState, które zapewniają lepszą integracje z Server Actions w formularzach:

// app/contact/actions.ts
'use server';

import { z } from 'zod';

// Schemat walidacji
const ContactSchema = z.object({
  name: z.string().min(1, { message: 'Imię jest wymagane' }),
  email: z.string().email({ message: 'Nieprawidłowy adres email' }),
  message: z.string().min(10, { message: 'Wiadomość musi mieć co najmniej 10 znaków' })
});

// Typ stanu formularza
type FormState = {
  errors?: {
    name?: string[];
    email?: string[];
    message?: string[];
  };
  message?: string;
  success?: boolean;
};

// Server Action z formatem zwrotnym dla useActionState
export async function submitContactForm(prevState: FormState, formData: FormData): Promise<FormState> {
  // Ekstrakcja danych
  const name = formData.get('name');
  const email = formData.get('email');
  const message = formData.get('message');

  // Walidacja
  const result = ContactSchema.safeParse({ name, email, message });

  if (!result.success) {
    return {
      errors: result.error.flatten().fieldErrors,
      message: 'Popraw błędy w formularzu',
      success: false
    };
  }

  try {
    // Zapis wiadomości do bazy, wysyłka emaila itp.
    await new Promise(resolve => setTimeout(resolve, 1000));

    // W rzeczywistej aplikacji, tu byłby kod do przetwarzania formularza
    console.log('Wiadomość kontaktowa:', result.data);

    return {
      errors: {},
      message: 'Wiadomość została wysłana!',
      success: true
    };
  } catch (error) {
    return {
      errors: {},
      message: 'Wystąpił błąd. Spróbuj ponownie później.',
      success: false
    };
  }
}

I odpowiadający komponent formularza:

// app/contact/page.tsx
'use client';

import { useActionState } from 'react';
import { useFormStatus } from 'react-dom';
import { submitContactForm } from './actions';

// Komponent przycisku z obsługą stanu formularza
function SubmitButton() {
  // useFormStatus daje dostęp do stanu formularza, w tym pending
  const { pending } = useFormStatus();

  return (
    <button
      type="submit"
      disabled={pending}
      className="w-full py-2 px-4 bg-blue-600 text-white rounded-md hover:bg-blue-700 disabled:opacity-50"
    >
      {pending ? 'Wysyłanie...' : 'Wyślij wiadomość'}
    </button>
  );
}

export default function ContactPage() {
  // Inicjalizacja stanu formularza
  const initialState = { errors: {}, message: '', success: false };

  // useActionState (łączy formularz z Server Action)
  const [state, formAction] = useActionState(submitContactForm, initialState);

  // Resetowanie formularza po udanym wysłaniu
  const formRef = React.useRef<HTMLFormElement>(null);

  React.useEffect(() => {
    if (state.success && formRef.current) {
      formRef.current.reset();
    }
  }, [state.success]);

  return (
    <div className="max-w-md mx-auto p-6 bg-white rounded-lg shadow-md">
      <h1 className="text-2xl font-bold mb-6">Kontakt</h1>

      {state.message && (
        <div className={`mb-4 p-3 rounded ${state.success ? 'bg-green-100 text-green-700' : 'bg-red-100 text-red-700'}`}>
          {state.message}
        </div>
      )}

      <form ref={formRef} action={formAction} className="space-y-4">
        <div>
          <label htmlFor="name" className="block text-sm font-medium text-gray-700">
            Imię i nazwisko
          </label>
          <input
            type="text"
            id="name"
            name="name"
            className={`mt-1 block w-full rounded-md ${state.errors?.name ? 'border-red-500' : 'border-gray-300'}`}
          />
          {state.errors?.name && (
            <p className="text-red-500 text-xs mt-1">{state.errors.name[0]}</p>
          )}
        </div>

        <div>
          <label htmlFor="email" className="block text-sm font-medium text-gray-700">
            Email
          </label>
          <input
            type="email"
            id="email"
            name="email"
            className={`mt-1 block w-full rounded-md ${state.errors?.email ? 'border-red-500' : 'border-gray-300'}`}
          />
          {state.errors?.email && (
            <p className="text-red-500 text-xs mt-1">{state.errors.email[0]}</p>
          )}
        </div>

        <div>
          <label htmlFor="message" className="block text-sm font-medium text-gray-700">
            Wiadomość
          </label>
          <textarea
            id="message"
            name="message"
            rows={4}
            className={`mt-1 block w-full rounded-md ${state.errors?.message ? 'border-red-500' : 'border-gray-300'}`}
          />
          {state.errors?.message && (
            <p className="text-red-500 text-xs mt-1">{state.errors.message[0]}</p>
          )}
        </div>

        <SubmitButton />
      </form>
    </div>
  );
}

Kluczowe zalety tego podejścia:

  1. useFormStatus - pozwala na łatwe śledzenie stanu pending formularza
  2. useActionState - zapewnia automatyczne zarządzanie stanem między serwerem a klientem
  3. Progresywne ulepszanie - formularz działa nawet bez JavaScript

Walidacja z TypeScript i Zod

Zod doskonale integruje się z TypeScript, co pozwala na definiowanie schematów walidacji, które jednocześnie służą jako typy:

// app/lib/validationSchemas.ts
import { z } from 'zod';

// Schemat produktu
export const ProductSchema = z.object({
  name: z.string().min(1, { message: 'Nazwa produktu jest wymagana' }),
  price: z.coerce.number().min(0.01, { message: 'Cena musi być większa od 0' }),
  description: z.string().min(10, { message: 'Opis musi mieć co najmniej 10 znaków' }),
  category: z.enum(['electronics', 'clothing', 'food', 'books'], {
    errorMap: () => ({ message: 'Wybierz poprawną kategorię' })
  }),
  quantity: z.coerce.number().int().min(0, { message: 'Ilość nie może być ujemna' }),
  featured: z.boolean().default(false)
});

// Typ produktu inferowany ze schematu
export type Product = z.infer<typeof ProductSchema>;

// Schemat do edycji produktu (wszystkie pola opcjonalne)
export const ProductUpdateSchema = ProductSchema.partial();
export type ProductUpdate = z.infer<typeof ProductUpdateSchema>;

Użycie w Server Action:

// app/products/actions.ts
'use server';

import { revalidatePath } from 'next/cache';
import { ProductSchema, ProductUpdateSchema, type Product } from '../lib/validationSchemas';

// Funkcja dodająca nowy produkt
export async function addProduct(formData: FormData) {
  // Konwersja FormData do obiektu
  const rawData = Object.fromEntries(formData.entries());

  // Konwersja pola 'featured' na boolean (checkbox)
  const productData = {
    ...rawData,
    featured: formData.get('featured') === 'on'
  };

  // Walidacja danych
  const validationResult = ProductSchema.safeParse(productData);

  if (!validationResult.success) {
    return {
      success: false,
      errors: validationResult.error.flatten().fieldErrors
    };
  }

  try {
    // W rzeczywistej aplikacji: zapisanie produktu w bazie danych
    // const newProduct = await db.product.create({ data: validationResult.data });
    console.log('Dodano nowy produkt:', validationResult.data);

    // Rewalidacja ścieżki, aby odświeżyć cache
    revalidatePath('/products');

    return {
      success: true,
      message: 'Produkt został dodany pomyślnie!'
    };
  } catch (error) {
    console.error('Błąd podczas dodawania produktu:', error);
    return {
      success: false,
      message: 'Wystąpił błąd podczas dodawania produktu.'
    };
  }
}

// Funkcja aktualizująca produkt (wszystkie pola opcjonalne)
export async function updateProduct(id: string, formData: FormData) {
  const rawData = Object.fromEntries(formData.entries());

  // Usuwamy puste pola, które nie powinny być aktualizowane
  for (const [key, value] of Object.entries(rawData)) {
    if (value === '') {
      delete rawData[key];
    }
  }

  // Konwersja pola 'featured' na boolean (checkbox)
  const productData = {
    ...rawData,
    featured: formData.has('featured')
  };

  // Walidacja częściowej aktualizacji
  const validationResult = ProductUpdateSchema.safeParse(productData);

  if (!validationResult.success) {
    return {
      success: false,
      errors: validationResult.error.flatten().fieldErrors
    };
  }

  try {
    // W rzeczywistej aplikacji: aktualizacja produktu w bazie danych
    // const updatedProduct = await db.product.update({
    //   where: { id },
    //   data: validationResult.data
    // });
    console.log(`Zaktualizowano produkt ${id}:`, validationResult.data);

    // Rewalidacja ścieżki, aby odświeżyć cache
    revalidatePath(`/products/${id}`);
    revalidatePath('/products');

    return {
      success: true,
      message: 'Produkt został zaktualizowany pomyślnie!'
    };
  } catch (error) {
    console.error('Błąd podczas aktualizacji produktu:', error);
    return {
      success: false,
      message: 'Wystąpił błąd podczas aktualizacji produktu.'
    };
  }
}

Bezpieczeństwo w Server Actions

Podczas implementacji walidacji w Server Actions, należy pamiętać o kilku kluczowych kwestiach bezpieczeństwa:

1. Ochrona przed CSRF (Cross-Site Request Forgery)

Next.js automatycznie zabezpiecza Server Actions przed atakami CSRF za pomocą tzw. "Action ID" i innych mechanizmów. Jednakże, dobrze jest mieć świadomość tej ochrony i stosować dodatkowe zabezpieczenia w krytycznych operacjach.

2. Rate Limiting

Dla wrażliwych operacji (np. logowanie, rejestracja) warto zastosować ograniczenie liczby żądań z jednego adresu IP:

'use server';

import { cookies } from 'next/headers';

// Prosta implementacja rate limitingu bazująca na cookies
export async function loginUser(formData: FormData) {
  const cookieStore = await cookies();
  const attemptsCookie = cookieStore.get('login_attempts');

  // Sprawdzanie liczby prób logowania
  const attempts = attemptsCookie ? parseInt(attemptsCookie.value, 10) : 0;

  if (attempts >= 5) {
    return {
      success: false,
      message: 'Zbyt wiele prób logowania. Spróbuj ponownie później.'
    };
  }

  // Reszta logiki logowania...

  // W przypadku nieudanego logowania zwiększamy licznik
  if (!success) {
    (await cookies()).set('login_attempts', String(attempts + 1), {
      maxAge: 60 * 15, // 15 minut
      httpOnly: true,
      secure: process.env.NODE_ENV === 'production',
      sameSite: 'strict'
    });
  } else {
    // Resetowanie licznika po udanym logowaniu
    (await cookies()).set('login_attempts', '0');
  }

  //
}

3. Sanityzacja danych wejściowych

Zawsze czyść i waliduj dane wejściowe przed ich przetworzeniem:

'use server';

import { z } from 'zod';
import { sanitizeHtml } from 'some-html-sanitizer';

export async function addComment(formData: FormData) {
  // Pobranie i wstępna sanityzacja
  const rawComment = formData.get('comment')?.toString() || '';
  const sanitizedComment = sanitizeHtml(rawComment, {
    allowedTags: ['b', 'i', 'em', 'strong'],
    allowedAttributes: {}
  });

  // Walidacja po sanityzacji
  const commentSchema = z.string().min(5).max(1000);
  const result = commentSchema.safeParse(sanitizedComment);

  if (!result.success) {
    return { success: false, errors: result.error.flatten().formErrors };
  }

  // Zapis do bazy...
}

4. Autoryzacja w Server Actions

Zawsze sprawdzaj uprawnienia użytkownika przed wykonaniem operacji:

'use server';

import { getServerSession } from 'next-auth';
import { authOptions } from '../auth';

export async function deleteProduct(productId: string) {
  // Pobranie sesji użytkownika
  const session = await getServerSession(authOptions);

  // Sprawdzenie czy użytkownik jest zalogowany
  if (!session?.user) {
    return {
      success: false,
      message: 'Musisz być zalogowany, aby wykonać tę operację.'
    };
  }

  // Sprawdzenie dodatkowych uprawnień (np. roli administratora)
  if (session.user.role !== 'admin') {
    return {
      success: false,
      message: 'Nie masz uprawnień do wykonania tej operacji.'
    };
  }

  // Wykonanie operacji...
}

Dobre praktyki przy walidacji danych w Server Actions

  1. Kombinacja walidacji klient+serwer - waliduj po stronie klienta dla lepszego UX, ale zawsze weryfikuj na serwerze

  2. Spójne komunikaty błędów - używaj tych samych komunikatów po obu stronach

  3. Progresywne ulepszanie - upewnij się, że formularze działają nawet bez JavaScript

  4. Typowanie end-to-end - wykorzystaj inferowanie typów z Zod dla spójności między klientem a serwerem

  5. Rewalidacja danych - używaj revalidatePath lub revalidateTag po mutacjach, aby odświeżyć cache

  6. Struktura błędów - utrzymuj spójny format odpowiedzi dla błędów

  7. Minimalizacja stanu klienta - przechowuj jak najwięcej logiki na serwerze

  8. Uwzględniaj dostępność - używaj odpowiednich opisów błędów i atrybutów ARIA

Podsumowanie

Server Actions w Next.js zapewniają potężny mechanizm do implementacji walidacji po stronie serwera, który łączy zalety bezpieczeństwa z dobrym doświadczeniem użytkownika:

  • Bezpieczeństwo - dane są zawsze walidowane na serwerze, niezależnie od stanu JavaScript klienta
  • Wydajność - brak konieczności tworzenia osobnych API endpoints
  • Progresywne ulepszanie - formularze działają nawet bez JavaScript
  • Spójność typów - możliwość dzielenia schematów walidacji między klientem a serwerem

Stosując opisane w tym module techniki i dobre praktyki, możesz tworzyć solidne, bezpieczne i przyjazne dla użytkownika formularze, które wykorzystują pełnię możliwości Next.js.

Kod do tej lekcji: App.tsx
import React, { useState } from 'react';

// Symulacja walidacji serwerowej z Server Actions w Next.js

type ServerState = {
  status: 'idle' | 'pending' | 'success' | 'error';
  errors: Record<string, string>;
  message: string;
};

// Symulacja Server Action
async function simulateServerAction(formData: Record<string, string>): Promise<ServerState> {
  // Symulacja opoznienia serwera
  await new Promise(r => setTimeout(r, 1000));

  const errors: Record<string, string> = {};

  // Walidacja serwerowa - niezalezna od klienta
  if (!formData.title || formData.title.length < 3) {
    errors.title = 'Tytul musi miec minimum 3 znaki';
  }
  if (!formData.content || formData.content.length < 10) {
    errors.content = 'Tresc musi miec minimum 10 znakow';
  }
  if (formData.title?.toLowerCase().includes('test')) {
    errors.title = 'Serwer odrzucil: slowo "test" jest zabronione';
  }

  if (Object.keys(errors).length > 0) {
    return { status: 'error', errors, message: 'Walidacja serwerowa nie powiodla sie' };
  }

  return { status: 'success', errors: {}, message: 'Dane zapisane na serwerze!' };
}

export default function ServerValidationDemo() {
  const [values, setValues] = useState({ title: '', content: '' });
  const [state, setState] = useState<ServerState>({ status: 'idle', errors: {}, message: '' });

  const handleSubmit = async (e: React.FormEvent) => {
    e.preventDefault();
    setState({ status: 'pending', errors: {}, message: 'Walidacja na serwerze...' });
    const result = await simulateServerAction(values);
    setState(result);
  };

  const inputStyle: React.CSSProperties = {
    width: '100%', padding: '10px', background: '#0d1117',
    border: '1px solid #333', borderRadius: 6, color: '#e0e0e0',
    fontFamily: 'monospace', fontSize: 13, boxSizing: 'border-box'
  };

  return (
    <div style={{ background: '#0f0f23', minHeight: '100vh', padding: 20, color: '#e0e0e0', fontFamily: 'monospace' }}>
      <h1 style={{ color: '#64ffda' }}>Server Actions - walidacja serwerowa</h1>
      <p style={{ color: '#888', fontSize: 13, marginBottom: 16 }}>
        Dane sa walidowane na serwerze - niezaleznie od JavaScript klienta.
        Sprobuj uzyc slowa "test" w tytule!
      </p>

      <div style={{ background: '#0d1117', borderRadius: 8, padding: 12, marginBottom: 16 }}>
        <pre style={{ color: '#ce93d8', fontSize: 11, margin: 0 }}>
{/* Przyklad Server Action */}
{'// app/actions.ts\n"use server"\n\nexport async function createPost(formData: FormData) {\n  const title = formData.get("title");\n  // walidacja na serwerze...\n}'}
        </pre>
      </div>

      <form onSubmit={handleSubmit} style={{ maxWidth: 400 }}>
        <div style={{ marginBottom: 12 }}>
          <label style={{ color: '#64ffda', fontSize: 12, display: 'block', marginBottom: 4 }}>Tytul</label>
          <input
            value={values.title}
            onChange={e => setValues(p => ({ ...p, title: e.target.value }))}
            style={{ ...inputStyle, borderColor: state.errors.title ? '#f44336' : '#333' }}
          />
          {state.errors.title && <div style={{ color: '#f44336', fontSize: 11, marginTop: 4 }}>{state.errors.title}</div>}
        </div>

        <div style={{ marginBottom: 12 }}>
          <label style={{ color: '#64ffda', fontSize: 12, display: 'block', marginBottom: 4 }}>Tresc (min 10 znakow)</label>
          <textarea
            value={values.content}
            onChange={e => setValues(p => ({ ...p, content: e.target.value }))}
            rows={3}
            style={{ ...inputStyle, resize: 'vertical', borderColor: state.errors.content ? '#f44336' : '#333' }}
          />
          {state.errors.content && <div style={{ color: '#f44336', fontSize: 11, marginTop: 4 }}>{state.errors.content}</div>}
        </div>

        <button type="submit" disabled={state.status === 'pending'} style={{
          background: state.status === 'pending' ? '#555' : '#ff9800',
          color: '#fff', border: 'none', borderRadius: 6,
          padding: '10px 20px', cursor: state.status === 'pending' ? 'wait' : 'pointer',
          fontFamily: 'monospace', width: '100%'
        }}>
          {state.status === 'pending' ? 'Walidacja na serwerze...' : 'Wyslij (Server Action)'}
        </button>
      </form>

      {state.message && state.status !== 'idle' && (
        <div style={{
          marginTop: 16, borderRadius: 8, padding: 12, maxWidth: 400,
          background: state.status === 'success' ? '#1b5e20' : state.status === 'error' ? '#3e2723' : '#1a2744',
          border: `1px solid ${state.status === 'success' ? '#4caf50' : state.status === 'error' ? '#f44336' : '#2196f3'}`,
        }}>
          <div style={{ color: state.status === 'success' ? '#4caf50' : state.status === 'error' ? '#f44336' : '#2196f3' }}>
            {state.message}
          </div>
        </div>
      )}
    </div>
  );
}

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Sprawdź się

Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.

  1. 1. Server Actions w Next.js pozwalają na:

  2. 2. Formik to:

To 2 z 4 pytań do tej lekcji. Pozostałe rozwiążesz w grze.

Zadania praktyczne w grze

  • Edytor kodu

    Utwórz formularz rejestracji używając React Hook Form z polami: username, email, password, confirmPassword

  • Układanie w poziomie

    Ułóż składnię input z register w React Hook Form

  • Klikanie w kolejności

    Ułóż składnię definicji schematu Zod

  • Edytor kodu

    Utwórz schema Zod dla formularza użytkownika z walidacją email, strong password, min/max lengths

  • Edytor kodu

    Utwórz Server Action do przetwarzania formularza kontaktowego z walidacją i wysyłaniem email

  • Układanie w pionie

    Ułóż elementy w prawidłowej kolejności: Install package → Import components → Cu

  • Klikanie w kolejności

    Ułóż składnię rejestracji inputa w React Hook Form

  • Edytor kodu

    Utwórz wieloetapowy formularz rejestracji z krokami: Personal Info, Account Details, Preferences

  1. PytanieServer Actions w Next.js pozwalają na:
  2. PytanieFormik to:
  3. Zadanie z kodemPraktyka: Utwórz formularz rejestracji używając React Hook
  4. Ułóż w kolejnościSkładnia input z register w React Hook Form
  5. Kliknij w kolejnościKolejność: const → schema → =
  6. Zadanie z kodemPraktyka: Utwórz schema Zod dla formularza użytkownika z
  7. PytanieProgressive Enhancement w formularzach oznacza:
  8. PytanieHook useActionState w React służy do:
  9. Zadanie z kodemPraktyka: Utwórz Server Action do przetwarzania formularza
  10. Ułóż w kolejnościKolejność: Install package → Import components → ...
  11. Kliknij w kolejnościSkładnia input z register
  12. Zadanie z kodemPraktyka: Utwórz wieloetapowy formularz rejestracji z

Przydatne artykuły