Symfony 7: API Platform dan Praktik Terbaik

Panduan lengkap membangun REST API profesional dengan Symfony 7 dan API Platform 4. State Providers, Processors, validasi, dan serialisasi dijelaskan dengan contoh praktis.

Panduan Symfony 7 API Platform 4: Praktik Terbaik REST API dengan PHP

API Platform 4 mengubah cara pembuatan REST API dan GraphQL dengan Symfony. Versi 4.4, dirilis pada September 2026, membawa composable filters, deprecated #[ApiFilter] decorators, dan dukungan native OpenAPI 3.2. Dikombinasikan dengan service container dan autowiring Symfony, membangun API profesional menjadi mudah.

Yang Baru di API Platform 4.4

Versi 4.4 mendeprekasi legacy #[ApiFilter] decorators (penghapusan direncanakan untuk 6.0) dan menggantinya dengan composable filters seperti ComparisonFilter, OrFilter, dan ChainFilter. Scalar UI menggantikan Swagger UI secara default sejak 4.3, dan OpenAPI 3.2 kini didukung penuh. Lihat release notes resmi untuk panduan migrasi.

Instalasi dan Konfigurasi Awal

API Platform diinstal dalam beberapa perintah menggunakan Symfony Flex. Konfigurasi default mencakup sebagian besar kasus penggunaan sekaligus tetap sepenuhnya dapat dikustomisasi.

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 secara otomatis mengkonfigurasi routes, dokumentasi OpenAPI, dan antarmuka Scalar UI yang dapat diakses di /api. Dokumentasi API Platform mencakup semua opsi konfigurasi.

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

Konfigurasi ini mendefinisikan format serialisasi, paginasi global, dan metadata dokumentasi API.

Membuat API Resource Sederhana

Atribut #[ApiResource] mengekspos entitas Doctrine sebagai resource REST. API Platform secara otomatis menghasilkan endpoint CRUD, dokumentasi OpenAPI, dan validasi dasar.

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 \;
    }
}

Entitas ini menghasilkan enam endpoint: GET /api/books, POST /api/books, GET /api/books/{id}, PUT /api/books/{id}, PATCH /api/books/{id}, dan DELETE /api/books/{id}.

UUID v7 Direkomendasikan

API Platform mendukung UUID v7 secara native sebagai identifier. Pendekatan ini meningkatkan keamanan (identifier yang tidak dapat diprediksi) dan performa (pengurutan alami berdasarkan tanggal pembuatan).

Serialization Groups untuk Mengontrol Data yang Diekspos

Serialization groups mendefinisikan secara presisi properti mana yang diekspos untuk pembacaan (normalization) dan penulisan (denormalization). Pemisahan ini esensial untuk keamanan dan fleksibilitas API. Untuk skenario serialisasi yang kompleks, komponen Symfony Serializer menawarkan opsi kustomisasi tambahan.

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;
    }
}

Dengan konfigurasi ini, plainPassword tidak pernah diekspos dalam respons tetapi dapat dikirimkan saat pembuatan atau pembaruan akun.

Siap menguasai wawancara Symfony Anda?

Berlatih dengan simulator interaktif, flashcards, dan tes teknis kami.

State Processors untuk Logika Bisnis

State Processors mencegat operasi persistensi untuk menambahkan logika bisnis. API Platform menyederhanakan pembuatannya melalui dependency injection berbasis atribut.

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(\, \, \, \);
    }
}

Pola komposisi ini memungkinkan penambahan logika apa pun (pengiriman email, event, logging) sambil mempertahankan perilaku persistensi standar. Untuk arsitektur berbasis event, processor bekerja dengan baik bersama Symfony Messenger.

Processor dengan Logika Kondisional

Sebuah processor dapat mengadaptasi perilakunya berdasarkan jenis operasi yang sedang dijalankan.

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 untuk Sumber Data Kustom

State Providers mengambil data dari sumber mana pun: API eksternal, cache, file, atau logika bisnis yang kompleks.

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);
        });
    }
}

Provider ini digunakan pada operasi khusus.

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
{
    // ...
}

Validasi Lanjutan dengan Grup Dinamis

API Platform mengintegrasikan komponen Validator Symfony secara native. Grup validasi dapat bervariasi berdasarkan operasi atau konteks.

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

Validasi Dinamis dengan Service

Untuk aturan validasi yang kompleks, generator grup kustom menawarkan fleksibilitas total.

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 \;
    }
}
Performa Validasi

Validasi yang kompleks dapat berdampak pada performa. Untuk impor massal, pertimbangkan untuk menonaktifkan sementara validasi tertentu atau menggunakan constraint asinkron.

Filter untuk Query yang Fleksibel

API Platform 4.4 merancang ulang sistem filter dengan composable filters. Legacy #[ApiFilter] decorator sudah deprecated (penghapusan direncanakan untuk 6.0), dan codemod tersedia untuk migrasi.

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

Filter-filter ini secara otomatis menghasilkan dokumentasi OpenAPI dan mengaktifkan query seperti:

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

API Platform 4.4 memperkenalkan filter baru: StartSearchFilter, EndSearchFilter, WordStartSearchFilter, dan composable wrappers seperti ComparisonFilter, OrFilter, dan ChainFilter.

Relasi dan Subresource

API Platform menangani relasi antar entitas dengan elegan melalui opsi serialisasi dan subresource.

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

Keamanan dan Kontrol Akses

API Platform terintegrasi secara mulus dengan sistem keamanan Symfony. Voter dan ekspresi keamanan mengontrol akses ke resource. Untuk gambaran lengkap pola keamanan Symfony, lihat Symfony Security: Voters, Firewalls dan Pertanyaan Interview.

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;
    }
}

Ekspresi object.getCustomer() == user memberikan akses ke entitas saat ini dan pengguna yang terkoneksi untuk pemeriksaan yang sangat granular.

Pengujian API Secara Otomatis

API Platform menyediakan trait PHPUnit untuk menguji endpoint dengan mudah.

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';
    }
}

Sumber Referensi

Checklist Praktik Terbaik API Platform Symfony

API Platform dengan Symfony merepresentasikan standar terkini dalam pembuatan REST API profesional dengan PHP. Pemisahan yang jelas antara State Providers (pembacaan) dan State Processors (penulisan), dikombinasikan dengan serialization groups dan sistem validasi, memungkinkan pembangunan API yang kokoh dan mudah dipelihara.

Checklist untuk API Berkualitas

  • Gunakan serialization groups yang berbeda untuk pembacaan dan penulisan
  • Implementasikan State Processors untuk logika bisnis (hashing kata sandi, notifikasi)
  • Konfigurasikan filter untuk pencarian dan pengurutan (migrasi dari deprecated #[ApiFilter] ke composable filters)
  • Terapkan validasi per operasi dengan grup yang sesuai
  • Amankan endpoint dengan ekspresi security
  • Tulis test fungsional untuk setiap endpoint
  • Dokumentasikan API melalui metadata OpenAPI

Mulai berlatih!

Uji pengetahuan Anda dengan simulator wawancara dan tes teknis kami.

Filosofi API Platform mendorong komposisi di atas pewarisan, serta konfigurasi di atas konvensi. Hasilnya adalah API yang skalabel, mudah diuji, dan sesuai standar REST/JSON-LD, siap produksi sejak hari pertama.

Tantangan harian

Bisakah kamu menemukan bug di Symfony?

Satu potongan kode nyata, satu bug tersembunyi, satu percobaan per hari. Tanpa akun untuk mencoba.

Anthony Fillion-Maillet

Ditulis oleh

Anthony Fillion-Maillet

Pendiri SharpSkill

Developer fullstack selama lebih dari 10 tahun. Ia menjalankan SharpSkill dan bertanggung jawab atas semua yang diterbitkan di sini.

Diperbarui 12 Oktober 2026

Tag

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

Bagikan

Artikel terkait