smokescreen laravel php Télécharger - smokescreen laravel php Téléchargement du code source

smokescreen laravel php

Autres catégories

4.0.0

Télécharger

Écran de fumée Laravel

Aperçu

Laravel Smokescreen est un package permettant de transformer vos modèles Laravel et d'autres entités.

Transformer les réponses de l'API
Transformez les charges utiles des tâches et des événements
Passe-partout et bootstrap minimaux
Prend en charge les relations complexes pour les données intégrées
Prend en charge le chargement rapide des relations
Permet de transformer différents types de ressources
Peut gérer la sérialisation vers des formats personnalisables

Ce package intègre étroitement le package rexlabs/smokescreen (Vanilla PHP) au framework Laravel, pour offrir la commodité et un passe-partout minimal lorsque vous travaillez avec des applications Laravel.

Usage

 <?php
class MyController extends Controller
{
    public function index ()
    {
        return Smokescreen:: transform (Post:: paginate ());
    }
    
     public function show ( Post $ post )
     {
        return Smokescreen:: transform ( $ post );
     }
}

laravel-smokescreen est démarré dans le conteneur d'application de Laravel, vous pouvez donc également le taper pour qu'il soit injecté dans le constructeur ou les méthodes de votre contrôleur.
L'utilisation de la façade (comme ci-dessus) est recommandée dans les méthodes du contrôleur, utilisez l'indication de type dans les classes de service (si nécessaire)
Vous pouvez également l'utiliser directement depuis le conteneur via app('smokescreen') comme indiqué ci-dessus.
Puisque nous implémentons l'interface Responsable , vous pouvez simplement renvoyer un écran de fumée à partir de n'importe quelle méthode de contrôleur.

Exigences

PHP >= 7.0
Laravel >= 5,5

Installation

Ce package est actuellement hébergé sur le référentiel packagiste privé de RexSoftware. Assurez-vous d’abord d’avoir configuré votre composer.json pour utiliser ce référentiel.

Installer le package

composer require rexlabs/laravel-smokescreen

Ce package sera découvert automatiquement et aucune configuration supplémentaire n’est nécessaire.

Configuration

Pour publier le fichier de configuration dans votre dossier app/config , exécutez la commande suivante :

php artisan vendor:publish --provider= ' RexlabsLaravelSmokescreenProvidersServiceProvider --tag=config '

Cela créera config/smokescreen.php :

 <?php
return [
    // Set the default namespace for resolving transformers when
    // they are not explicitly provided.
    ' transformer_namespace ' => ' AppTransformers ' ,
    
    // Override the default serializer to be used.
    // If not specified - the Smokescreen DefaultSerializer will be used.
    ' default_serializer ' => null ,

    // Set the default request parameter key which is parsed for
    // the list of includes.
    ' include_key ' => ' include ' ,
];

API

transform() : Définir la ressource à transformer

$smokescreen->transform(mixed $resource, mixed $transformer = null);

 <?php
$ smokescreen -> transform (Post:: find ( 1 ));
$ smokescreen -> transform (Post:: all ());
$ smokescreen -> transform (Post:: paginate ());
$ smokescreen -> transform (Post:: find ( 1 ), new SomeOtherTransformer );

Smokescreen déterminera automatiquement le type de ressource en cours de transformation.
Il déduira également la classe Transformer à utiliser si elle n'est pas fournie.

item() : définir une ressource d'élément unique à transformer

$smokescreen->item(mixed $item, mixed $transformer = null);

 <?php
$ smokescreen -> item (Post:: find ( 1 ));
$ smokescreen -> item (Post:: find ( 1 ), new SomeOtherTransformer );

Similaire à transform() mais n'accepte qu'un élément.

collection() : Définir la ressource de collection à transformer

$smokescreen->collection(mixed $collection, mixed $transformer = null);

 <?php
$ smokescreen -> collection (Post:: all ());
$ smokescreen -> collection (Post:: paginate ());
$ smokescreen -> collection (Post:: paginate (), new SomeOtherTransformer );

Similaire à transform() mais n'accepte qu'une collection.

transformWith() : définit le transformateur à utiliser sur la ressource précédemment définie

$smokescreen->transformWith(TransformerInterface|callable $transformer);

 <?php
$ smokescreen -> transform (Post:: find ( 1 ))
    -> transformWith ( new SomeOtherTransformer );

C'est une alternative au passage du transformateur directement aux méthodes de ressources.

serializeWith() : remplace le sérialiseur à utiliser

 <?php
$ smokescreen -> serializeWith ( new MyCustomSerializer );

Vous ne devez définir cette valeur que si vous envisagez d'utiliser une sérialisation différente de celle par défaut.
Nous fournissons DefaultSerializer par défaut, il renvoie des collections imbriquées sous un nœud "data" et une ressource d'élément sans aucune imbrication.
Votre sérialiseur personnalisé doit implémenter l'interface SerializerInterface .

loadRelationsVia() : remplace le chargeur de relations Laravel par défaut

$smokescreen->loadRelationsVia(RelationsLoaderInterface $loader);

 <?php
$ smokescreen -> loadRelationsVia ( new MyRelationsLoader );

Vous ne devez définir ceci que si vous prévoyez d'utiliser un chargeur différent de celui par défaut,
Nous fournissons RelationsLoader par défaut qui charge avec impatience les relations pour les ressources de collection.
Votre chargeur personnalisé doit implémenter l'interface RelationsLoaderInterface et fournir une méthode load() .

solveTransformerVia() : remplace le résolveur de transformateur par défaut

$smokescreen->loadTransformersVia(TransformerResolverInterface $loader);

 <?php
$ smokescreen -> loadTransformersVia ( new MyTransformerResolver );

Le résolveur est utilisé lorsqu'un transformateur n'est pas explicitement défini sur une ressource.
Le résolveur par défaut de ce package essaie de trouver une classe de transformateur correspondante dans le chemin défini dans le chemin smokescreen.transformer_namespace et l'instancie via le conteneur d'application.
Vous ne devez définir cette valeur que si vous envisagez d'utiliser un résolveur différent de celui par défaut.
Votre résolveur personnalisé doit implémenter l'interface TransformersLoaderInterface et fournir une méthode resolve(ResourceInterface) .

réponse() : accéder à l'objet de réponse généré

$response = $smokescreen->response(int $statusCode = 200, array $headers = [], int $options = 0);

 <?php
$ smokescreen -> response ()
    -> header ( ' X-Custom-Header ' , ' boo ' )
    -> setStatusCode ( 405 );

Cette méthode renvoie un objet IlluminateHttpJsonResponse il n'est donc pas chaînable.
Toutes les méthodes JsonResponse prises en charge peuvent être appliquées.
Vous pouvez toujours renvoyer response() directement depuis votre contrôleur puisqu'il s'agit d'un objet JsonResponse .
Vous pouvez également utiliser withResponse($callback) pour appliquer les modifications tout en prenant en charge la chaînabilité.
Remarque : le premier appel à response() met en cache le résultat afin que l'intégralité de l'ensemble de données ne soit pas régénéré à chaque fois, cela signifie que la transmission de tous les paramètres lors des appels suivants sera ignorée. Vous pouvez utiliser clearResponse() ou manipuler directement l'objet JsonResponse .

freshResponse() : générer un nouvel objet Response

$response = $smokescreen->freshResponse(int $statusCode = 200, array $headers = [], int $options = 0);

Contrairement à response() cette méthode renvoie un nouvel objet JsonResponse non mis en cache (en appelant d'abord clearResponse() ).
Cette méthode renvoie un objet IlluminateHttpJsonResponse il n'est donc pas chaînable. Voir withResponse() pour une méthode chaînable.
Toutes les méthodes JsonResponse prises en charge peuvent être appliquées.

withResponse() : appliquer les modifications à l'objet de réponse généré

$smokescreen->withResponse(callable $apply);

 <?php
$ smokescreen -> withResponse ( function ( JsonResponse $ response ) {
    $ response -> header ( ' X-Crypto-Alert ' , ' all your coins are worthless! ' );
});

Fournir un rappel qui accepte un objet JsonResponse et manipule la réponse
Cette méthode est chaînable contrairement à response()

clearResponse() : efface toute réponse mise en cache

$smokescreen->clearResponse();

 <?php
$ smokescreen -> response ();       // Data is generated, response object is built and cached
$ smokescreen -> response ( 500 );    // NOPE - Cached, wont be changed!
$ smokescreen -> clearResponse ();
$ smokescreen -> response ( 500 );    // Response is re-generated

Réinitialiser tout objet de réponse mis en cache

Transformateurs

Exemple de transformateur

 <?php
class PostTransformer extends AbstractTransformer
{
    protected $ includes = [
        ' user ' => ' default|relation:user|method:includeTheDamnUser ' ,
        ' comments ' => ' relation ' ,
    ];

    public function transform ( Post $ post ): array
    {
        return [
            ' id ' => $ post -> id ,
            ' user ' => $ this -> when ( $ post -> user_id , [
                ' id ' => $ post -> user_id ,
            ]),
            ' title ' => $ post -> title ,
            ' summary ' => $ post -> summary ,
            ' body ' => $ post -> body ,
            ' created_at ' => utc_datetime ( $ post -> created_at ),
            ' updated_at ' => utc_datetime ( $ post -> updated_at ),
        ];
    }

    public function includeTheDamnUser ( Post $ post )
    {
        return $ this -> item ( $ post -> user ); // Infer Transformer
    }

    public function includeComments ( Post $ post )
    {
        return $ this -> collection ( $ post -> comments , new CommentTransformer );
    }
}

Vous déclarez vos inclusions disponibles via le tableau $includes
Chaque inclusion accepte 0 ou plusieurs des directives suivantes :
- default : Cette inclusion est toujours activée quelles que soient les inclusions demandées
- relation : Indique qu'une relation doit être chargée avec impatience. Si le nom de la relation est différent, spécifiez-le comme relation:othername
- method : Par défaut, la clé d'inclusion est mappée sur include{IncludeKey} vous pouvez fournir la méthode à utiliser à la place
Votre méthode transform() doit renvoyer un tableau.
Définissez vos méthodes d'inclusion au format include{IncludeKey}(Model) - elles doivent renvoyer soit une collection() , soit un item()
when() est une méthode d'assistance simple qui accepte une condition et renvoie soit la valeur donnée lorsqu'elle est vraie, soit null (par défaut) lorsqu'elle est fausse. Dans l'exemple ci-dessus, le nœud "user" sera null si aucun user_id n'est défini sur l'objet $post .