Symfony 7 : API Platform et bonnes pratiques

Guide complet pour créer des APIs REST professionnelles avec Symfony 7 et API Platform 4. State Providers, Processors, validation et sérialisation expliqués.

Guide API Platform et bonnes pratiques pour Symfony 7

API Platform 4 transforme la création d'APIs REST et GraphQL avec Symfony. La version 4.4, publiée en septembre 2026, apporte les filtres composables, la dépréciation des décorateurs #[ApiFilter] et le support natif d'OpenAPI 3.2. Combiné avec le conteneur de services et l'autowiring de Symfony, construire une API professionnelle devient simple.

Nouveautés API Platform 4.4

La version 4.4 déprécie les décorateurs #[ApiFilter] historiques (suppression prévue pour la 6.0) au profit de filtres composables comme ComparisonFilter, OrFilter et ChainFilter. Scalar UI remplace Swagger UI par défaut depuis la 4.3, et OpenAPI 3.2 est désormais supporté. Consultez les notes de version officielles pour le guide de migration.

Installation et configuration initiale

API Platform s'installe en quelques commandes avec Symfony Flex. La configuration par défaut couvre la majorité des cas d'usage tout en restant entièrement personnalisable.

bash
# terminal
# Create a new Symfony project with API Platform
composer create-project symfony/skeleton my-api
cd my-api

# Install API Platform with Doctrine ORM
composer require api

# Verify installation
php bin/console debug:router | grep api

Symfony Flex configure automatiquement les routes, la documentation OpenAPI et l'interface Scalar UI accessible à /api. La documentation API Platform détaille toutes les options de configuration.

yaml
# config/packages/api_platform.yaml
api_platform:
    title: 'My API'
    version: '1.0.0'
    # Supported response formats
    formats:
        jsonld: ['application/ld+json']
        json: ['application/json']
    # OpenAPI documentation
    swagger:
        versions: [3]
    # Default pagination
    defaults:
        pagination_items_per_page: 30
        pagination_maximum_items_per_page: 100

Cette configuration définit les formats de sérialisation, la pagination globale et les métadonnées de la documentation API.

Création d'une ressource API simple

L'attribut #[ApiResource] expose une entité Doctrine comme ressource REST. API Platform génère automatiquement les endpoints CRUD, la documentation OpenAPI et les validations de base.

php
<?php
// src/Entity/Book.php

namespace App\Entity;

use ApiPlatform\Metadata\ApiResource;
use ApiPlatform\Metadata\Get;
use ApiPlatform\Metadata\GetCollection;
use ApiPlatform\Metadata\Post;
use ApiPlatform\Metadata\Put;
use ApiPlatform\Metadata\Patch;
use ApiPlatform\Metadata\Delete;
use Doctrine\ORM\Mapping as ORM;
use Symfony\Component\Validator\Constraints as Assert;

#[ORM\Entity]
#[ApiResource(
    // Explicit definition of available operations
    operations: [
        new GetCollection(),
        new Post(),
        new Get(),
        new Put(),
        new Patch(),
        new Delete(),
    ],
    // Default ordering for collections
    order: ['publishedAt' => 'DESC'],
    // Pagination configuration for this resource
    paginationItemsPerPage: 20
)]
class Book
{
    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column]
    private ?int \ = null;

    #[ORM\Column(length: 255)]
    #[Assert\NotBlank(message: 'Title is required')]
    #[Assert\Length(min: 2, max: 255)]
    private ?string \ = null;

    #[ORM\Column(type: 'text')]
    #[Assert\NotBlank]
    private ?string \ = null;

    #[ORM\Column(length: 13, unique: true)]
    #[Assert\Isbn]
    private ?string \ = null;

    #[ORM\Column]
    private ?\DateTimeImmutable \ = null;

    // Getters and setters...
    public function getId(): ?int
    {
        return \->id;
    }

    public function getTitle(): ?string
    {
        return \->title;
    }

    public function setTitle(string \): static
    {
        \->title = \;
        return \;
    }

    public function getDescription(): ?string
    {
        return \->description;
    }

    public function setDescription(string \): static
    {
        \->description = \;
        return \;
    }

    public function getIsbn(): ?string
    {
        return \->isbn;
    }

    public function setIsbn(string \): static
    {
        \->isbn = \;
        return \;
    }

    public function getPublishedAt(): ?\DateTimeImmutable
    {
        return \->publishedAt;
    }

    public function setPublishedAt(\DateTimeImmutable \): static
    {
        \->publishedAt = \;
        return \;
    }
}

Cette entité génère six endpoints : GET /api/books, POST /api/books, GET /api/books/{id}, PUT /api/books/{id}, PATCH /api/books/{id} et DELETE /api/books/{id}.

UUID v7 recommandé

API Platform supporte nativement les UUID v7 comme identifiants. Cette approche améliore la sécurité (identifiants non prédictibles) et les performances (tri naturel par date de création).

Groupes de sérialisation pour contrôler les données exposées

Les groupes de sérialisation permettent de définir précisément quelles propriétés sont exposées en lecture (normalization) et en écriture (denormalization). Cette séparation est essentielle pour la sécurité et la flexibilité de l'API. Pour les scénarios de sérialisation complexes, le composant Serializer de Symfony offre des options de personnalisation supplémentaires.

php
<?php
// src/Entity/User.php

namespace App\Entity;

use ApiPlatform\Metadata\ApiResource;
use ApiPlatform\Metadata\Get;
use ApiPlatform\Metadata\GetCollection;
use ApiPlatform\Metadata\Post;
use ApiPlatform\Metadata\Put;
use ApiPlatform\Metadata\Patch;
use ApiPlatform\Metadata\Delete;
use Doctrine\ORM\Mapping as ORM;
use Symfony\Component\Serializer\Annotation\Groups;
use Symfony\Component\Validator\Constraints as Assert;
use Symfony\Component\Security\Core\User\UserInterface;
use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
use App\State\UserPasswordHasher;

#[ORM\Entity]
#[ORM\Table(name: '`user`')]
#[UniqueEntity('email')]
#[ApiResource(
    operations: [
        new GetCollection(),
        // Custom processor for password hashing
        new Post(processor: UserPasswordHasher::class,
                 validationContext: ['groups' => ['Default', 'user:create']]),
        new Get(),
        new Put(processor: UserPasswordHasher::class),
        new Patch(processor: UserPasswordHasher::class),
        new Delete(),
    ],
    // Properties exposed when reading
    normalizationContext: ['groups' => ['user:read']],
    // Properties accepted when writing
    denormalizationContext: ['groups' => ['user:create', 'user:update']],
)]
class User implements UserInterface, PasswordAuthenticatedUserInterface
{
    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column]
    #[Groups(['user:read'])]
    private ?int \ = null;

    #[ORM\Column(length: 180, unique: true)]
    #[Assert\NotBlank]
    #[Assert\Email]
    #[Groups(['user:read', 'user:create', 'user:update'])]
    private ?string \ = null;

    #[ORM\Column]
    private ?string \ = null;

    // Never exposed when reading, only when writing
    #[Assert\NotBlank(groups: ['user:create'])]
    #[Groups(['user:create', 'user:update'])]
    private ?string \ = null;

    #[ORM\Column(length: 100)]
    #[Groups(['user:read', 'user:create', 'user:update'])]
    private ?string \ = null;

    #[ORM\Column(type: 'json')]
    #[Groups(['user:read'])]
    private array \ = [];

    #[ORM\Column]
    #[Groups(['user:read'])]
    private ?\DateTimeImmutable \ = null;

    public function __construct()
    {
        \->createdAt = new \DateTimeImmutable();
    }

    // UserInterface implementation
    public function getUserIdentifier(): string
    {
        return (string) \->email;
    }

    public function getRoles(): array
    {
        \ = \->roles;
        \[] = 'ROLE_USER';
        return array_unique(\);
    }

    public function getPassword(): string
    {
        return \->password;
    }

    public function eraseCredentials(): void
    {
        \->plainPassword = null;
    }

    // Getters and setters...
    public function getId(): ?int
    {
        return \->id;
    }

    public function getEmail(): ?string
    {
        return \->email;
    }

    public function setEmail(string \): static
    {
        \->email = \;
        return \;
    }

    public function setPassword(string \): static
    {
        \->password = \;
        return \;
    }

    public function getPlainPassword(): ?string
    {
        return \->plainPassword;
    }

    public function setPlainPassword(?string \): static
    {
        \->plainPassword = \;
        return \;
    }

    public function getFullName(): ?string
    {
        return \->fullName;
    }

    public function setFullName(string \): static
    {
        \->fullName = \;
        return \;
    }

    public function setRoles(array \): static
    {
        \->roles = \;
        return \;
    }

    public function getCreatedAt(): ?\DateTimeImmutable
    {
        return \->createdAt;
    }
}

Avec cette configuration, plainPassword n'est jamais exposé en réponse mais peut être envoyé lors de la création ou mise à jour.

Prêt à réussir tes entretiens Symfony ?

Entraîne-toi avec nos simulateurs interactifs, fiches express et tests techniques.

State Processors pour la logique métier

Les State Processors interceptent les opérations de persistance pour ajouter de la logique métier. API Platform simplifie leur création grâce à l'injection de dépendances via attributs.

php
<?php
// src/State/UserPasswordHasher.php

namespace App\State;

use ApiPlatform\Metadata\Operation;
use ApiPlatform\State\ProcessorInterface;
use App\Entity\User;
use Symfony\Component\DependencyInjection\Attribute\Autowire;
use Symfony\Component\PasswordHasher\Hasher\UserPasswordHasherInterface;

/**
 * Processor that hashes password before persistence
 * @implements ProcessorInterface<User, User>
 */
final class UserPasswordHasher implements ProcessorInterface
{
    public function __construct(
        // Injection of standard Doctrine processor
        #[Autowire(service: 'api_platform.doctrine.orm.state.persist_processor')]
        private ProcessorInterface \,
        private UserPasswordHasherInterface \,
    ) {
    }

    public function process(mixed \, Operation \, array \ = [], array \ = []): User
    {
        // Hash password if provided
        if (\->getPlainPassword()) {
            \ = \->passwordHasher->hashPassword(
                \,
                \->getPlainPassword()
            );
            \->setPassword(\);
            \->eraseCredentials();
        }

        // Delegate persistence to standard processor
        return \->persistProcessor->process(\, \, \, \);
    }
}

Ce pattern de composition permet d'ajouter n'importe quelle logique (envoi d'emails, événements, logs) tout en conservant le comportement standard de persistance. Pour les architectures event-driven, les processors s'intègrent parfaitement avec Symfony Messenger.

Processor avec logique conditionnelle

Un processor peut adapter son comportement selon le type d'opération.

php
<?php
// src/State/BookProcessor.php

namespace App\State;

use ApiPlatform\Metadata\DeleteOperationInterface;
use ApiPlatform\Metadata\Operation;
use ApiPlatform\Metadata\Post;
use ApiPlatform\State\ProcessorInterface;
use App\Entity\Book;
use App\Service\NotificationService;
use App\Service\SearchIndexer;
use Symfony\Component\DependencyInjection\Attribute\Autowire;

/**
 * @implements ProcessorInterface<Book, Book|void>
 */
final class BookProcessor implements ProcessorInterface
{
    public function __construct(
        #[Autowire(service: 'api_platform.doctrine.orm.state.persist_processor')]
        private ProcessorInterface \,
        #[Autowire(service: 'api_platform.doctrine.orm.state.remove_processor')]
        private ProcessorInterface \,
        private NotificationService \,
        private SearchIndexer \,
    ) {
    }

    public function process(mixed \, Operation \, array \ = [], array \ = []): mixed
    {
        // Deletion: use remove processor
        if (\ instanceof DeleteOperationInterface) {
            \->searchIndexer->remove(\);
            return \->removeProcessor->process(\, \, \, \);
        }

        // Creation: set publication date
        if (\ instanceof Post) {
            \->setPublishedAt(new \DateTimeImmutable());
        }

        // Standard persistence
        \ = \->persistProcessor->process(\, \, \, \);

        // Post-processing: indexing and notification
        \->searchIndexer->index(\);

        if (\ instanceof Post) {
            \->notifications->notifyNewBook(\);
        }

        return \;
    }
}

State Providers pour les sources de données personnalisées

Les State Providers permettent de récupérer des données depuis n'importe quelle source : API externe, cache, fichiers, ou logique métier complexe.

php
<?php
// src/State/PopularBooksProvider.php

namespace App\State;

use ApiPlatform\Metadata\Operation;
use ApiPlatform\State\ProviderInterface;
use App\Entity\Book;
use App\Repository\BookRepository;
use Symfony\Contracts\Cache\CacheInterface;
use Symfony\Contracts\Cache\ItemInterface;

/**
 * Provider that returns popular books with caching
 * @implements ProviderInterface<Book>
 */
final class PopularBooksProvider implements ProviderInterface
{
    public function __construct(
        private BookRepository \,
        private CacheInterface \,
    ) {
    }

    public function provide(Operation \, array \ = [], array \ = []): array
    {
        // 5-minute cache for popular books
        return \->cache->get('popular_books', function (ItemInterface \) {
            \->expiresAfter(300);

            return \->bookRepository->findPopular(limit: 10);
        });
    }
}

Ce provider s'utilise sur une opération dédiée.

php
<?php
// src/Entity/Book.php (excerpt)

use App\State\PopularBooksProvider;

#[ApiResource(
    operations: [
        // ... other operations
        new GetCollection(
            uriTemplate: '/books/popular',
            provider: PopularBooksProvider::class,
            paginationEnabled: false,
        ),
    ],
)]
class Book
{
    // ...
}

Validation avancée avec groupes dynamiques

API Platform intègre nativement le composant Validator de Symfony. Les groupes de validation peuvent varier selon l'opération ou le contexte.

php
<?php
// src/Entity/Article.php

namespace App\Entity;

use ApiPlatform\Metadata\ApiResource;
use ApiPlatform\Metadata\Get;
use ApiPlatform\Metadata\GetCollection;
use ApiPlatform\Metadata\Post;
use ApiPlatform\Metadata\Put;
use Doctrine\ORM\Mapping as ORM;
use Symfony\Component\Validator\Constraints as Assert;

#[ORM\Entity]
#[ApiResource(
    operations: [
        new GetCollection(),
        new Get(),
        // Strict validation on creation
        new Post(validationContext: ['groups' => ['Default', 'article:create']]),
        // More lenient validation for updates
        new Put(validationContext: ['groups' => ['Default', 'article:update']]),
    ],
)]
class Article
{
    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column]
    private ?int \ = null;

    #[ORM\Column(length: 255)]
    #[Assert\NotBlank]
    #[Assert\Length(min: 10, max: 255)]
    private ?string \ = null;

    #[ORM\Column(type: 'text')]
    #[Assert\NotBlank]
    // Minimum 500 characters on creation
    #[Assert\Length(min: 500, groups: ['article:create'])]
    // Minimum 100 characters for updates
    #[Assert\Length(min: 100, groups: ['article:update'])]
    private ?string \ = null;

    #[ORM\Column(length: 50)]
    #[Assert\NotBlank(groups: ['article:create'])]
    #[Assert\Choice(choices: ['draft', 'published', 'archived'])]
    private ?string \ = 'draft';

    #[ORM\Column(nullable: true)]
    // Required only if status is "published"
    #[Assert\NotBlank(groups: ['article:publish'])]
    private ?\DateTimeImmutable \ = null;

    // Getters and setters...
}

Validation dynamique avec un service

Pour des règles de validation complexes, un générateur de groupes personnalisé offre une flexibilité totale.

php
<?php
// src/Validator/ArticleGroupsGenerator.php

namespace App\Validator;

use ApiPlatform\Symfony\Validator\ValidationGroupsGeneratorInterface;
use App\Entity\Article;
use Symfony\Bundle\SecurityBundle\Security;

final class ArticleGroupsGenerator implements ValidationGroupsGeneratorInterface
{
    public function __construct(
        private Security \,
    ) {
    }

    public function __invoke(object \): array
    {
        assert(\ instanceof Article);

        \ = ['Default'];

        // Admins have fewer restrictions
        if (\->security->isGranted('ROLE_ADMIN')) {
            \[] = 'admin';
            return \;
        }

        // Additional validation if publishing
        if (\->getStatus() === 'published') {
            \[] = 'article:publish';
        }

        return \;
    }
}
Performance des validations

Les validations complexes peuvent impacter les performances. Pour les imports en masse, envisagez de désactiver temporairement certaines validations ou d'utiliser des contraintes asynchrones.

Filtres pour des requêtes flexibles

API Platform 4.4 repense le système de filtres avec les filtres composables. Le décorateur #[ApiFilter] historique est déprécié (suppression prévue pour la 6.0), et un codemod est disponible pour la migration.

php
<?php
// src/Entity/Product.php

namespace App\Entity;

use ApiPlatform\Metadata\ApiResource;
use ApiPlatform\Metadata\ApiFilter;
use ApiPlatform\Doctrine\Orm\Filter\SearchFilter;
use ApiPlatform\Doctrine\Orm\Filter\RangeFilter;
use ApiPlatform\Doctrine\Orm\Filter\OrderFilter;
use ApiPlatform\Doctrine\Orm\Filter\BooleanFilter;
use ApiPlatform\Doctrine\Orm\Filter\DateFilter;
use Doctrine\ORM\Mapping as ORM;

#[ORM\Entity]
#[ApiResource]
// Text search on name and description
#[ApiFilter(SearchFilter::class, properties: [
    'name' => 'partial',       // LIKE %value%
    'description' => 'partial',
    'category.name' => 'exact', // Search on relation
    'sku' => 'exact',          // Exact match
])]
// Range filtering
#[ApiFilter(RangeFilter::class, properties: ['price', 'stock'])]
// Date filtering
#[ApiFilter(DateFilter::class, properties: ['createdAt', 'updatedAt'])]
// Boolean filtering
#[ApiFilter(BooleanFilter::class, properties: ['isActive', 'isFeatured'])]
// Customizable sorting
#[ApiFilter(OrderFilter::class, properties: [
    'name',
    'price',
    'createdAt',
], arguments: ['orderParameterName' => 'sort'])]
class Product
{
    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column]
    private ?int \ = null;

    #[ORM\Column(length: 255)]
    private ?string \ = null;

    #[ORM\Column(type: 'text', nullable: true)]
    private ?string \ = null;

    #[ORM\Column(length: 50, unique: true)]
    private ?string \ = null;

    #[ORM\Column(type: 'decimal', precision: 10, scale: 2)]
    private ?string \ = null;

    #[ORM\Column]
    private ?int \ = null;

    #[ORM\Column]
    private ?bool \ = true;

    #[ORM\Column]
    private ?bool \ = false;

    #[ORM\ManyToOne(targetEntity: Category::class)]
    private ?Category \ = null;

    #[ORM\Column]
    private ?\DateTimeImmutable \ = null;

    #[ORM\Column(nullable: true)]
    private ?\DateTimeImmutable \ = null;

    // Getters and setters...
}

Ces filtres génèrent automatiquement la documentation OpenAPI et permettent des requêtes comme :

text
GET /api/products?name=phone&price[gte]=100&price[lte]=500&isActive=true&sort[price]=asc

API Platform 4.4 introduit de nouveaux filtres : StartSearchFilter, EndSearchFilter, WordStartSearchFilter, et des wrappers composables comme ComparisonFilter, OrFilter et ChainFilter.

Relations et sous-ressources

API Platform gère élégamment les relations entre entités avec des options de sérialisation et des sous-ressources.

php
<?php
// src/Entity/Author.php

namespace App\Entity;

use ApiPlatform\Metadata\ApiResource;
use ApiPlatform\Metadata\Get;
use ApiPlatform\Metadata\GetCollection;
use ApiPlatform\Metadata\Link;
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use Doctrine\ORM\Mapping as ORM;
use Symfony\Component\Serializer\Annotation\Groups;

#[ORM\Entity]
#[ApiResource(
    normalizationContext: ['groups' => ['author:read']],
)]
class Author
{
    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column]
    #[Groups(['author:read', 'book:read'])]
    private ?int \ = null;

    #[ORM\Column(length: 255)]
    #[Groups(['author:read', 'book:read'])]
    private ?string \ = null;

    #[ORM\Column(type: 'text', nullable: true)]
    #[Groups(['author:read'])]
    private ?string \ = null;

    #[ORM\OneToMany(mappedBy: 'author', targetEntity: Book::class)]
    #[Groups(['author:read'])]
    private Collection \;

    public function __construct()
    {
        \->books = new ArrayCollection();
    }

    // Getters and setters...
}
php
<?php
// src/Entity/Book.php (with relation)

namespace App\Entity;

use ApiPlatform\Metadata\ApiResource;
use ApiPlatform\Metadata\Get;
use ApiPlatform\Metadata\GetCollection;
use ApiPlatform\Metadata\Link;
use Doctrine\ORM\Mapping as ORM;
use Symfony\Component\Serializer\Annotation\Groups;

#[ORM\Entity]
#[ApiResource(
    normalizationContext: ['groups' => ['book:read']],
)]
// Subresource: GET /api/authors/{authorId}/books
#[ApiResource(
    uriTemplate: '/authors/{authorId}/books',
    operations: [new GetCollection()],
    uriVariables: [
        'authorId' => new Link(
            fromProperty: 'books',
            fromClass: Author::class
        ),
    ],
    normalizationContext: ['groups' => ['book:read']],
)]
class Book
{
    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column]
    #[Groups(['book:read', 'author:read'])]
    private ?int \ = null;

    #[ORM\Column(length: 255)]
    #[Groups(['book:read', 'author:read'])]
    private ?string \ = null;

    #[ORM\ManyToOne(targetEntity: Author::class, inversedBy: 'books')]
    #[ORM\JoinColumn(nullable: false)]
    #[Groups(['book:read'])]
    private ?Author \ = null;

    // Getters and setters...
}

Sécurité et contrôle d'accès

API Platform s'intègre parfaitement avec le système de sécurité Symfony. Les voters et expressions de sécurité contrôlent l'accès aux ressources. Pour une vue complète des patterns de sécurité Symfony, consultez Symfony Security : Voters, Firewalls et questions d'entretien.

php
<?php
// src/Entity/Order.php

namespace App\Entity;

use ApiPlatform\Metadata\ApiResource;
use ApiPlatform\Metadata\Get;
use ApiPlatform\Metadata\GetCollection;
use ApiPlatform\Metadata\Post;
use ApiPlatform\Metadata\Patch;
use ApiPlatform\Metadata\Delete;
use Doctrine\ORM\Mapping as ORM;

#[ORM\Entity]
#[ApiResource(
    operations: [
        // List: authenticated users see their orders
        new GetCollection(
            security: "is_granted('ROLE_USER')",
            // Automatic filter by connected user
            provider: UserOrdersProvider::class,
        ),
        // Creation: any authenticated user
        new Post(
            security: "is_granted('ROLE_USER')",
            processor: CreateOrderProcessor::class,
        ),
        // Read: owner or admin
        new Get(
            security: "is_granted('ROLE_ADMIN') or object.getCustomer() == user",
            securityMessage: "Access denied to this order.",
        ),
        // Modification: admin only
        new Patch(
            security: "is_granted('ROLE_ADMIN')",
        ),
        // Deletion: admin only
        new Delete(
            security: "is_granted('ROLE_ADMIN')",
        ),
    ],
)]
class Order
{
    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column]
    private ?int \ = null;

    #[ORM\ManyToOne(targetEntity: User::class)]
    #[ORM\JoinColumn(nullable: false)]
    private ?User \ = null;

    #[ORM\Column(length: 50)]
    private ?string \ = 'pending';

    #[ORM\Column(type: 'decimal', precision: 10, scale: 2)]
    private ?string \ = null;

    #[ORM\Column]
    private ?\DateTimeImmutable \ = null;

    // Getters...
    public function getCustomer(): ?User
    {
        return \->customer;
    }
}

L'expression object.getCustomer() == user donne accès à l'entité courante et à l'utilisateur connecté pour des vérifications fines.

Tests automatisés de l'API

API Platform fournit des traits PHPUnit pour tester facilement les endpoints.

php
<?php
// tests/Api/BookTest.php

namespace App\Tests\Api;

use ApiPlatform\Symfony\Bundle\Test\ApiTestCase;
use App\Entity\Book;
use App\Factory\BookFactory;
use App\Factory\UserFactory;
use Zenstruck\Foundry\Test\Factories;
use Zenstruck\Foundry\Test\ResetDatabase;

class BookTest extends ApiTestCase
{
    use ResetDatabase;
    use Factories;

    public function testGetCollection(): void
    {
        // Create test data
        BookFactory::createMany(30);

        // GET request on collection
        \ = static::createClient()->request('GET', '/api/books');

        // Assertions
        \->assertResponseIsSuccessful();
        \->assertResponseHeaderSame('content-type', 'application/ld+json; charset=utf-8');
        \->assertJsonContains([
            '@context' => '/api/contexts/Book',
            '@type' => 'Collection',
            'totalItems' => 30,
        ]);
        // Verify pagination (20 items per page)
        \->assertCount(20, \->toArray()['member']);
    }

    public function testCreateBook(): void
    {
        \ = UserFactory::createOne(['roles' => ['ROLE_ADMIN']]);

        static::createClient()->request('POST', '/api/books', [
            'auth_bearer' => \->getToken(\),
            'json' => [
                'title' => 'Clean Code',
                'description' => 'A Handbook of Agile Software Craftsmanship',
                'isbn' => '9780132350884',
            ],
        ]);

        \->assertResponseStatusCodeSame(201);
        \->assertJsonContains([
            '@type' => 'Book',
            'title' => 'Clean Code',
        ]);
    }

    public function testCreateBookValidationFails(): void
    {
        \ = UserFactory::createOne(['roles' => ['ROLE_ADMIN']]);

        static::createClient()->request('POST', '/api/books', [
            'auth_bearer' => \->getToken(\),
            'json' => [
                'title' => '', // Empty title = error
                'isbn' => 'invalid-isbn',
            ],
        ]);

        \->assertResponseStatusCodeSame(422);
        \->assertJsonContains([
            '@type' => 'ConstraintViolationList',
            'violations' => [
                ['propertyPath' => 'title', 'message' => 'Title is required'],
            ],
        ]);
    }

    private function getToken(object \): string
    {
        // Implementation depends on your authentication system
        return 'test_token';
    }
}

Sources

Checklist des bonnes pratiques API Platform Symfony

API Platform avec Symfony représente l'état de l'art pour créer des APIs REST professionnelles en PHP. La séparation claire entre State Providers (lecture) et State Processors (écriture), combinée aux groupes de sérialisation et au système de validation, permet de construire des APIs robustes et maintenables.

Checklist pour une API de qualité

  • Utiliser des groupes de sérialisation distincts pour lecture et écriture
  • Implémenter des State Processors pour la logique métier (hash de mot de passe, notifications)
  • Configurer des filtres pour les recherches et le tri (migrer des décorateurs #[ApiFilter] dépréciés vers les filtres composables)
  • Appliquer des validations par opération avec des groupes
  • Sécuriser les endpoints avec des expressions de sécurité
  • Écrire des tests fonctionnels pour chaque endpoint
  • Documenter l'API via les métadonnées OpenAPI

Passe à la pratique !

Teste tes connaissances avec nos simulateurs d'entretien et tests techniques.

La philosophie d'API Platform encourage la composition plutôt que l'héritage, et la configuration plutôt que la convention. Le résultat : des APIs évolutives, testables et conformes aux standards REST/JSON-LD, prêtes pour la production dès le premier jour.

Défi du jour

Tu saurais repérer le bug en Symfony ?

Un vrai bout de code, un bug caché, une tentative par jour. Sans compte pour essayer.

Anthony Fillion-Maillet

Écrit par

Anthony Fillion-Maillet

Fondateur de SharpSkill

Développeur fullstack depuis plus de 10 ans. Il dirige SharpSkill et répond de tout ce qui y est publié.

Mis à jour le 12 octobre 2026

Tags

#symfony
#api platform
#php
#rest api
#api development

Partager

Articles similaires