api-platform:make-provider

API Platform Make Provider

Génère un State Provider personnalisé pour API Platform. Les providers sont responsables de la récupération des données pour les opérations de lecture (GET, GetCollection).

Variables

• {ResourceName} - Nom de la resource en PascalCase
• {providerType} - Type : item, collection, ou les deux
• {namespace} - Namespace du projet (défaut: App)

Outputs

• src/State/{ResourceName}Provider.php

Instructions à Exécuter

IMPORTANT : Exécute ce workflow étape par étape :

1. Identifier la resource cible

• Si $ARGUMENTS est fourni, utiliser comme nom de la resource
• Sinon, utiliser AskUserQuestion :

  Question: "Pour quelle resource créer un State Provider ?"
  Header: "Resource"
  

2. Vérifier la resource existante

• Chercher src/Entity/{ResourceName}.php ou src/ApiResource/{ResourceName}.php avec Glob
• Si la resource existe, lire le fichier pour comprendre sa structure
• Si la resource n'existe pas, informer l'utilisateur et proposer /api-platform:make-resource

3. Choisir le type de provider

• Utiliser AskUserQuestion :

  Question: "Quel type de provider créer ?"
  Header: "Type"
  Options:
    - "Complet (Recommandé)" : "Gère à la fois les items (Get) et les collections (GetCollection)"
    - "Item uniquement" : "Gère uniquement la récupération d'un item (Get)"
    - "Collection uniquement" : "Gère uniquement la récupération de collections (GetCollection)"
  

4. Choisir la source de données

• Utiliser AskUserQuestion :

  Question: "Quelle est la source de données ?"
  Header: "Source"
  Options:
    - "Doctrine (Recommandé)" : "Décorer le provider Doctrine existant pour ajouter de la logique"
    - "Service externe" : "API tierce, microservice, ou autre source"
    - "Custom" : "Logique métier complexe, agrégation de sources multiples"
  

5. Détecter le namespace du projet

• Lire composer.json avec Read
• Extraire le namespace depuis autoload.psr-4
• Si non trouvé, utiliser App par défaut

6. Générer le State Provider

Provider décorant Doctrine :

<?php

declare(strict_types=1);

namespace {namespace}\State;

use ApiPlatform\Metadata\CollectionOperationInterface;
use ApiPlatform\Metadata\Operation;
use ApiPlatform\State\ProviderInterface;

/**
 * @implements ProviderInterface<{ResourceName}>
 */
final readonly class {ResourceName}Provider implements ProviderInterface
{
    public function __construct(
        private ProviderInterface $decorated,
    ) {
    }

    public function provide(Operation $operation, array $uriVariables = [], array $context = []): object|array|null
    {
        if ($operation instanceof CollectionOperationInterface) {
            return $this->provideCollection($operation, $uriVariables, $context);
        }

        return $this->provideItem($operation, $uriVariables, $context);
    }

    private function provideCollection(Operation $operation, array $uriVariables, array $context): iterable
    {
        $items = $this->decorated->provide($operation, $uriVariables, $context);

        // Logique personnalisée sur la collection
        return $items;
    }

    private function provideItem(Operation $operation, array $uriVariables, array $context): ?object
    {
        $item = $this->decorated->provide($operation, $uriVariables, $context);

        // Logique personnalisée sur l'item
        return $item;
    }
}

Provider depuis source externe :

<?php

declare(strict_types=1);

namespace {namespace}\State;

use ApiPlatform\Metadata\CollectionOperationInterface;
use ApiPlatform\Metadata\Operation;
use ApiPlatform\State\ProviderInterface;
use {namespace}\ApiResource\{ResourceName};

/**
 * @implements ProviderInterface<{ResourceName}>
 */
final readonly class {ResourceName}Provider implements ProviderInterface
{
    public function __construct(
        // Injecter le client HTTP ou le service métier
    ) {
    }

    public function provide(Operation $operation, array $uriVariables = [], array $context = []): object|array|null
    {
        if ($operation instanceof CollectionOperationInterface) {
            // Récupérer et retourner la collection
            return [];
        }

        // Récupérer et retourner un item
        $id = $uriVariables['id'] ?? null;

        return null;
    }
}

7. Configurer le service (si décoration Doctrine)

• Vérifier si config/services.yaml existe
• Informer l'utilisateur de la configuration nécessaire si autoconfiguration Symfony :

# config/services.yaml
services:
    App\State\{ResourceName}Provider:
        arguments:
            $decorated: '@api_platform.doctrine.orm.state.item_provider'
        # Ou pour décorer le collection provider :
        # $decorated: '@api_platform.doctrine.orm.state.collection_provider'

8. Mettre à jour la resource

• Lire la resource avec Read
• Ajouter le provider dans l'attribut #[ApiResource] :

#[ApiResource(
    provider: {ResourceName}Provider::class,
)]

9. Afficher le résumé

State Provider {ResourceName}Provider généré

Fichiers créés :
- src/State/{ResourceName}Provider.php

Configuration requise :
- Vérifier config/services.yaml (si décoration Doctrine)

Resource mise à jour :
- provider: {ResourceName}Provider::class ajouté

Prochaines étapes :
- Implémenter la logique métier dans provide()
- Créer le processor associé : /api-platform:make-processor {ResourceName}
- Tester : /api-platform:make-test {ResourceName}

Patterns appliqués

State Provider

• Implémente ProviderInterface
• Classe final readonly
• Séparation item/collection dans des méthodes privées
• Décoration du provider Doctrine pour ajouter de la logique

Bonnes pratiques

• Ne pas dupliquer la logique Doctrine si elle peut être décorée
• Utiliser CollectionOperationInterface pour distinguer item/collection
• Typer le template générique ProviderInterface<ResourceName>
• Retourner null pour un item non trouvé (API Platform gère le 404)

Notes

• Le provider est appelé pour toutes les opérations de lecture (GET)
• Pour les opérations d'écriture, utiliser un State Processor
• La pagination est gérée automatiquement si le provider retourne un Paginator
• Le provider Doctrine peut être décoré pour ajouter des filtres custom, du contrôle d'accès, etc.