download do código-fonte smokescreen laravel php smokescreen laravel php php

smokescreen laravel php

Outras categorias

4.0.0

Baixar

Cortina de Fumaça Laravel

Visão geral

Laravel Smokescreen é um pacote para transformar seus modelos Laravel e outras entidades.

Transforme as respostas da API
Transformar cargas úteis de trabalhos e eventos
Padrão mínimo e bootstrap
Suporta relacionamentos complexos para dados incorporados
Suporta carregamento ansioso de relacionamentos
Permite transformar diferentes tipos de recursos
Pode lidar com a serialização em formatos personalizáveis

Este pacote integra fortemente o pacote rexlabs/smokescreen (Vanilla PHP) com a estrutura Laravel, para fornecer conveniência e padrão mínimo ao trabalhar com aplicativos Laravel.

Uso

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

laravel-smokescreen é inicializado no contêiner do aplicativo Laravel, então você também pode digitar a dica para que ele seja injetado no construtor ou nos métodos do seu controlador.
O uso da fachada (como acima) é recomendado nos métodos do controlador, use dicas de tipo nas classes de serviço (se necessário)
Você também pode usá-lo diretamente do contêiner via app('smokescreen') conforme mostrado acima.
Como implementamos a interface Responsable , você pode simplesmente retornar a cortina de fumaça de qualquer método do controlador.

Requisitos

PHP >= 7.0
Laravel >= 5,5

Instalação

Este pacote está atualmente hospedado no repositório empacotador privado da RexSoftware. Primeiro, certifique-se de ter configurado seu composer.json para usar este repositório.

Instalar pacote

composer require rexlabs/laravel-smokescreen

Este pacote será descoberto automaticamente e nenhuma configuração adicional será necessária.

Configuração

Para publicar o arquivo de configuração em sua pasta app/config , execute o seguinte comando:

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

Isso criará 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(): Define o recurso a ser transformado

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

A Smokescreen determinará automaticamente o tipo de recurso que está sendo transformado.
Ele também inferirá a classe Transformer a ser usada, se não for fornecida.

item(): Define recurso de item único a ser transformado

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

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

Semelhante a transform() mas aceita apenas um item.

coleção(): Define o recurso de coleção a ser transformado

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

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

Semelhante a transform() mas aceita apenas uma coleção.

transformWith(): Defina o transformador para usar no recurso definido anteriormente

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

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

É uma alternativa para passar o transformador diretamente para métodos de recursos.

serializeWith(): Substitui o serializador a ser usado

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

Você só precisa definir isso se planeja usar uma serialização diferente da padrão.
Fornecemos DefaultSerializer como padrão, ele retorna coleções aninhadas em um nó "data" e um recurso de item sem qualquer aninhamento.
Seu serializador personalizado deve implementar a interface SerializerInterface .

loadRelationsVia(): Substitui o carregador de relações padrão do Laravel

$smokescreen->loadRelationsVia(RelationsLoaderInterface $loader);

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

Você só precisa definir isso se planeja usar um carregador diferente do padrão,
Fornecemos RelationsLoader como padrão, que carrega relacionamentos para recursos de coleção.
Seu carregador personalizado deve implementar a interface RelationsLoaderInterface e fornecer um método load() .

resolveTransformerVia(): Substitui o resolvedor do transformador padrão

$smokescreen->loadTransformersVia(TransformerResolverInterface $loader);

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

O resolvedor é usado quando um transformador não está definido explicitamente em um recurso.
O resolvedor padrão neste pacote tenta encontrar uma classe de transformador correspondente dentro do caminho definido no caminho smokescreen.transformer_namespace e a instancia por meio do contêiner do aplicativo.
Você só precisa definir isso se planeja usar um resolvedor diferente do padrão.
Seu resolvedor personalizado deve implementar a interface TransformersLoaderInterface e fornecer um método resolve(ResourceInterface) .

resposta(): acessa o objeto de resposta gerado

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

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

Este método retorna um objeto IlluminateHttpJsonResponse portanto não pode ser encadeado.
Todos os métodos JsonResponse suportados podem ser aplicados.
Você ainda pode retornar response() diretamente do seu controlador, pois é um objeto JsonResponse .
Como alternativa, você pode usar withResponse($callback) para aplicar alterações e ainda oferecer suporte à capacidade de encadeamento.
Nota: a primeira chamada para response() armazena em cache o resultado para que todo o conjunto de dados não seja gerado novamente todas as vezes, isso significa que a passagem de quaisquer parâmetros nas chamadas subsequentes será ignorada. Você pode usar clearResponse() ou manipular o objeto JsonResponse diretamente.

FreshResponse(): gera um novo objeto Response

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

Ao contrário de response() este método retorna um novo objeto JsonResponse não armazenado em cache (chamando clearResponse() primeiro).
Este método retorna um objeto IlluminateHttpJsonResponse portanto não pode ser encadeado. Veja withResponse() para um método encadeado.
Todos os métodos JsonResponse suportados podem ser aplicados.

withResponse(): aplica alterações ao objeto de resposta gerado

$smokescreen->withResponse(callable $apply);

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

Forneça um retorno de chamada que aceite um objeto JsonResponse e manipule a resposta
Este método é encadeado, ao contrário de response()

clearResponse(): Limpa qualquer resposta em 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

Redefinir qualquer objeto de resposta em cache

Transformadores

Exemplo de transformador

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

Você declara suas inclusões disponíveis através do array $includes
Cada inclusão aceita 0 ou mais das seguintes diretivas:
- default : Esta inclusão está sempre habilitada, independentemente das inclusões solicitadas
- relation : indica que uma relação deve ser carregada antecipadamente. Se o nome da relação for diferente, especifique-o como relation:othername
- method : por padrão, a chave de inclusão é mapeada para include{IncludeKey} você pode fornecer o método a ser usado
Seu método transform() deve retornar um array.
Defina seus métodos de inclusão no formato include{IncludeKey}(Model) - eles devem retornar uma collection() ou um item()
when() é um método auxiliar simples que aceita uma condição e retorna o valor fornecido quando verdadeiro ou nulo (por padrão) quando falso. No exemplo acima, o nó "user" será null se não houver user_id definido no objeto $post .