Formularze i obsługa POST - Lemonade Framework

Pełny przepływ formularza

Typowy server-rendered flow wygląda tak: GET renderuje formularz, POST przechodzi przez CsrfMiddleware, a controller odczytuje wejście i waliduje je jeden raz. Przy błędzie zwraca formularz z błędami i pierwotnymi wartościami; przy sukcesie przekazuje zapis do usługi aplikacyjnej, zapisuje flash message, wykonuje redirect i kończy kolejnym GET. To wzorzec Post/Redirect/Get. Więcej o regułach znajdziesz w Walidacji, a o dodatkowych guardach HTTP w Middleware.

Trasy i ochrona CSRF

Trasę GET pozostaw prostą, a CsrfMiddleware podepnij do trasy POST zmieniającej stan. Widok renderuje token przez wbudowany helper CSRF, dzięki czemu request i view korzystają z tego samego mechanizmu frameworka.

<?php

use App\Controllers\ContactController;
use Lemonade\Framework\Routing\Router;
use Lemonade\Framework\Security\Csrf\CsrfMiddleware;

return static function (Router $router): void {
    $router->getNamed('contact.form', '/contact', ContactController::class . '@form');

    $router
        ->postNamed('contact.submit', '/contact', ContactController::class . '@submit')
        ->middleware(CsrfMiddleware::class);
};

Akcja GET, akcja POST, walidacja i redirect

Akcja GET przygotowuje wartości domyślne i renderuje stronę. Akcja POST odczytuje dane przez helpery controllera, waliduje je raz, przy błędzie zwraca ten sam formularz z HTTP 422, a przy sukcesie wywołuje usługę aplikacyjną do zapisu, ustawia flash message i wykonuje redirect.

<?php

declare(strict_types=1);

namespace App\Controllers;

use App\Services\ContactSubmissionService;
use Lemonade\Framework\Core\AbstractController;
use Lemonade\Framework\Validation\ValidationSchema;
use Psr\Http\Message\ResponseInterface;

final class ContactController extends AbstractController
{
    public function __construct(
        private readonly ContactSubmissionService $contactService,
    ) {}

    public function form(): ResponseInterface
    {
        return $this->renderForm(
            values: [
                'name' => '',
                'email' => '',
                'message' => '',
            ],
            errors: [],
        );
    }

    public function submit(): ResponseInterface
    {
        $values = [
            'name' => $this->inputString('name'),
            'email' => $this->inputString('email'),
            'message' => $this->inputString('message'),
        ];

        $schema = ValidationSchema::create()
            ->field('name', 'Name')
                ->required()
                ->maxLength(100)
            ->end()
            ->field('email', 'E-mail')
                ->required()
                ->email()
            ->end()
            ->field('message', 'Message')
                ->required()
                ->maxLength(2000)
            ->end();

        $result = $this->validator()->validate($values, $schema);

        if (!$result->isValid()) {
            return $this->renderForm(
                values: $values,
                errors: $result->errors(),
                status: 422,
            );
        }

        $this->contactService->store($result->validated());
        $this->flash()->set('success', 'Your message has been sent.');

        return $this->redirect($this->url()->route('contact.form'));
    }

    /**
     * @param array{name:string,email:string,message:string} $values
     * @param array<string, string> $errors
     */
    private function renderForm(array $values, array $errors, int $status = 200): ResponseInterface
    {
        return $this->html(
            $this->view()->template('layouts.app', 'pages.contact-form', [
                'values' => $values,
                'errors' => $errors,
            ]),
            $status,
        );
    }
}

Renderuj formularz z CSRF, wartościami i błędami

Form view renderuje csrfField(), przywraca przesłane wartości do inputów i na przekierowanym GET odczytuje success flash message. values i errors przekazuj jawnie z controllera, aby widok nie zależał od ukrytych helperów aplikacji demo.

<?php

/**
 * @var \Lemonade\Framework\View\View $this
 * @var \Lemonade\Framework\View\ViewHelpers $helpers
 * @var \Lemonade\Framework\View\RequestViewHelpers $requestHelpers
 * @var array<string, string> $errors
 * @var array{name:string,email:string,message:string} $values
 */
?>
<?php if ($success = $requestHelpers->flash('success')): ?>
    <div class="alert alert-success"><?= e((string) $success) ?></div>
<?php endif; ?>

<form method="post" action="<?= e($helpers->url('contact.submit')) ?>">
    <?= $helpers->csrfField() ?>

    <input name="name" value="<?= e($values['name']) ?>">
    <input name="email" value="<?= e($values['email']) ?>">
    <textarea name="message"><?= e($values['message']) ?></textarea>

    <?php if (isset($errors['message'])): ?>
        <p><?= e($errors['message']) ?></p>
    <?php endif; ?>

    <button type="submit">Send</button>
</form>

Zapis trzymaj poza controllerem

Controller powinien odpowiadać za orkiestrację HTTP. Sam zapis może trafić do małej usługi aplikacyjnej, gdy przestaje być tylko prostym połączeniem requestu z frameworkiem. Dzięki temu controller pozostaje czytelny bez narzucania warstwy service lub repository.

<?php

declare(strict_types=1);

namespace App\Services;

use Lemonade\Framework\Database\Database;

final class ContactSubmissionService
{
    public function __construct(
        private readonly Database $db,
    ) {}

    /**
     * @param array{name:string,email:string,message:string} $data
     */
    public function store(array $data): void
    {
        $this->db->table('contact_messages')->insert($data);
    }
}