Prologo

Primi Passi

Architettura

Le Basi

Approfondimenti

Sicurezza

Database

Eloquent ORM

Testing

Package

Risorse API

Introduzione

Quando costruisci un’API, potresti aver bisogno di un livello di trasformazione tra i tuoi modelli Eloquent e le risposte JSON che vengono effettivamente restituite agli utenti della tua applicazione. Ad esempio, potresti voler mostrare alcuni attributi solo a una parte degli utenti, oppure potresti voler includere sempre certe relazioni nella rappresentazione JSON dei tuoi modelli. Le classi risorsa di Eloquent ti permettono di trasformare in modo espressivo e semplice i tuoi modelli e le collezioni di modelli in JSON.

Naturalmente, puoi sempre convertire i modelli o le collezioni Eloquent in JSON utilizzando i loro metodi toJson; tuttavia, le risorse di Eloquent offrono un controllo più granulare e robusto sulla serializzazione JSON dei tuoi modelli e delle loro relazioni.

Generazione delle Risorse

Per creare una classe risorsa, puoi usare il comando Artisan make:resource. Di default, le risorse saranno collocate nella directory app/Http/Resources della tua applicazione. Le risorse estendono la classe Illuminate\Http\Resources\Json\JsonResource:

php artisan make:resource UserResource

Collezioni di Risorse

Oltre a generare risorse che trasformano singoli modelli, puoi creare risorse responsabili della trasformazione di collezioni di modelli. Questo permette alle tue risposte JSON di includere link e altre informazioni meta rilevanti per un’intera collezione di una determinata risorsa.

Per creare una collezione di risorse, dovresti usare l’opzione --collection quando crei la risorsa. In alternativa, includere la parola Collection nel nome della risorsa indicherà a Laravel di creare una risorsa di collezione. Le risorse di collezione estendono la classe Illuminate\Http\Resources\Json\ResourceCollection:

php artisan make:resource User --collection

php artisan make:resource UserCollection

Panoramica del Concetto

Questa è una panoramica di alto livello delle risorse e delle collezioni di risorse. È fortemente consigliato leggere le altre sezioni di questa documentazione per comprendere meglio la personalizzazione e la potenza offerte dalle risorse.

Prima di esplorare tutte le opzioni disponibili quando si scrivono le risorse, diamo prima un’occhiata generale a come vengono utilizzate le risorse all’interno di Laravel. Una classe risorsa rappresenta un singolo modello che deve essere trasformato in una struttura JSON. Ad esempio, ecco una semplice classe risorsa UserResource:

<?php

namespace App\Http\Resources;

use Illuminate\Http\Request;
use Illuminate\Http\Resources\Json\JsonResource;

class UserResource extends JsonResource
{
    /**
     * Trasforma la risorsa in un array.
     *
     * @return array<string, mixed>
     */
    public function toArray(Request $request): array
    {
        return [
            'id' => $this->id,
            'name' => $this->name,
            'email' => $this->email,
            'created_at' => $this->created_at,
            'updated_at' => $this->updated_at,
        ];
    }
}

Ogni classe risorsa definisce un metodo toArray che restituisce l’array di attributi che devono essere convertiti in JSON quando la risorsa viene restituita come risposta da una route o da un metodo del controller.

Nota che possiamo accedere direttamente alle proprietà del modello dalla variabile $this. Questo perché una classe risorsa proxy automaticamente l’accesso alle proprietà e ai metodi al modello sottostante per un accesso comodo. Una volta definita la risorsa, può essere restituita da una route o da un controller. La risorsa accetta l’istanza del modello sottostante tramite il suo costruttore:

use App\Http\Resources\UserResource;
use App\Models\User;

Route::get('/user/{id}', function (string $id) {
    return new UserResource(User::findOrFail($id));
});

Collezioni di Risorse

Se stai restituendo una collezione di risorse o una risposta paginata, dovresti utilizzare il metodo collection fornito dalla tua classe di risorsa quando crei l’istanza della risorsa nella tua rotta o controller:

use App\Http\Resources\UserResource;
use App\Models\User;

Route::get('/users', function () {
    return UserResource::collection(User::all());
});

Tieni presente che questo non permette l’aggiunta di metadati personalizzati che potrebbero dover essere restituiti con la tua collezione. Se desideri personalizzare la risposta della collezione di risorse, puoi creare una risorsa dedicata per rappresentare la collezione:

php artisan make:resource UserCollection

Una volta generata la classe della collezione di risorse, puoi facilmente definire i metadati che devono essere inclusi nella risposta:

<?php

namespace App\Http\Resources;

use Illuminate\Http\Request;
use Illuminate\Http\Resources\Json\ResourceCollection;

class UserCollection extends ResourceCollection
{
    /**
     * Trasforma la collezione di risorse in un array.
     *
     * @return array<int|string, mixed>
     */
    public function toArray(Request $request): array
    {
        return [
            'data' => $this->collection,
            'links' => [
                'self' => 'link-value',
            ],
        ];
    }
}

Dopo aver definito la tua collezione di risorse, puoi restituirla da una rotta o controller:

use App\Http\Resources\UserCollection;
use App\Models\User;

Route::get('/users', function () {
    return new UserCollection(User::all());
});

Preservare le Chiavi delle Collezioni

Quando si restituisce una collezione di risorse da una route, Laravel resetta le chiavi della collezione in modo che siano in ordine numerico. Tuttavia, puoi aggiungere una proprietà preserveKeys alla tua classe risorsa per indicare se le chiavi originali della collezione devono essere mantenute:

<?php

namespace App\Http\Resources;

use Illuminate\Http\Resources\Json\JsonResource;

class UserResource extends JsonResource
{
    /**
     * Indica se le chiavi della collezione delle risorse devono essere preservate.
     *
     * @var bool
     */
    public $preserveKeys = true;
}

Quando la proprietà preserveKeys è impostata su true, le chiavi della collezione verranno preservate quando la collezione viene restituita da una route o da un controller:

use App\Http\Resources\UserResource;
use App\Models\User;

Route::get('/users', function () {
    return UserResource::collection(User::all()->keyBy->id);
});

Personalizzare la Classe Resource Sottostante

Di solito, la proprietà $this->collection di una resource collection viene automaticamente riempita mappando ogni elemento della collezione alla sua classe resource singolare. Si presume che la classe resource singolare sia il nome della classe della collezione senza la parte finale Collection. Inoltre, a seconda delle tue preferenze, la classe resource singolare può avere o meno il suffisso Resource.

Per esempio, UserCollection tenterà di mappare le istanze utente fornite nella resource UserResource. Per personalizzare questo comportamento, puoi sovrascrivere la proprietà $collects della tua resource collection:

<?php

namespace App\Http\Resources;

use Illuminate\Http\Resources\Json\ResourceCollection;

class UserCollection extends ResourceCollection
{
    /**
     * La resource che questa resource raccoglie.
     *
     * @var string
     */
    public $collects = Member::class;
}

Scrivere Risorse

Se non hai letto la panoramica dei concetti, ti consigliamo vivamente di farlo prima di continuare con questa documentazione.

Le risorse devono solo trasformare un modello dato in un array. Quindi, ogni risorsa contiene un metodo toArray che traduce gli attributi del tuo modello in un array compatibile con l’API che può essere restituito dalle rotte o dai controller della tua applicazione:

    <?php

    namespace App\Http\Resources;

    use Illuminate\Http\Request;
    use Illuminate\Http\Resources\Json\JsonResource;

    class UserResource extends JsonResource
    {
        /**
         * Trasforma la risorsa in un array.
         *
         * @return array<string, mixed>
         */
        public function toArray(Request $request): array
        {
            return [
                'id' => $this->id,
                'name' => $this->name,
                'email' => $this->email,
                'created_at' => $this->created_at,
                'updated_at' => $this->updated_at,
            ];
        }
    }

Una volta definita una risorsa, può essere restituita direttamente da una rotta o da un controller:

    use App\Http\Resources\UserResource;
    use App\Models\User;

    Route::get('/user/{id}', function (string $id) {
        return new UserResource(User::findOrFail($id));
    });

Relazioni

Se desideri includere risorse correlate nella tua risposta, puoi aggiungerle all’array restituito dal metodo toArray della tua risorsa. In questo esempio, utilizzeremo il metodo collection della risorsa PostResource per aggiungere i post del blog dell’utente alla risposta della risorsa:

use App\Http\Resources\PostResource;
use Illuminate\Http\Request;

/**
 * Trasforma la risorsa in un array.
 *
 * @return array<string, mixed>
 */
public function toArray(Request $request): array
{
    return [
        'id' => $this->id,
        'name' => $this->name,
        'email' => $this->email,
        'posts' => PostResource::collection($this->posts),
        'created_at' => $this->created_at,
        'updated_at' => $this->updated_at,
    ];
}

Se desideri includere le relazioni solo quando sono già state caricate, consulta la documentazione su relazioni condizionali.

Collezioni di Risorse

Mentre le resources trasformano un singolo modello in un array, le resource collections trasformano una collezione di modelli in un array. Tuttavia, non è necessario definire una classe di resource collection per ogni tuo modello, poiché tutte le resources forniscono un metodo collection per generare una resource collection "ad-hoc" al volo:

use App\Http\Resources\UserResource;
use App\Models\User;

Route::get('/users', function () {
    return UserResource::collection(User::all());
});

Se però hai bisogno di personalizzare i meta dati restituiti con la collezione, è necessario definire una tua resource collection:

<?php

namespace App\Http\Resources;

use Illuminate\Http\Request;
use Illuminate\Http\Resources\Json\ResourceCollection;

class UserCollection extends ResourceCollection
{
    /**
     * Trasforma la collezione di risorse in un array.
     *
     * @return array<string, mixed>
     */
    public function toArray(Request $request): array
    {
        return [
            'data' => $this->collection,
            'links' => [
                'self' => 'link-value',
            ],
        ];
    }
}

Come le resources singole, anche le resource collections possono essere restituite direttamente da routes o controller:

use App\Http\Resources\UserCollection;
use App\Models\User;

Route::get('/users', function () {
    return new UserCollection(User::all());
});

Incapsulamento Dati

Per impostazione predefinita, la tua risorsa più esterna viene incapsulata in una chiave data quando la risposta della risorsa viene convertita in JSON. Quindi, ad esempio, una risposta tipica di una collezione di risorse appare come segue:

{
    "data": [
        {
            "id": 1,
            "name": "Eladio Schroeder Sr.",
            "email": "therese28@example.com"
        },
        {
            "id": 2,
            "name": "Liliana Mayert",
            "email": "evandervort@example.com"
        }
    ]
}

Se desideri disabilitare l’incapsulamento della risorsa più esterna, dovresti invocare il metodo withoutWrapping sulla classe base Illuminate\Http\Resources\Json\JsonResource. Di solito, dovresti chiamare questo metodo dal tuo AppServiceProvider o da un altro provider di servizi che viene caricato ad ogni richiesta della tua applicazione:

    <?php

    namespace App\Providers;

    use Illuminate\Http\Resources\Json\JsonResource;
    use Illuminate\Support\ServiceProvider;

    class AppServiceProvider extends ServiceProvider
    {
        /**
         * Register any application services.
         */
        public function register(): void
        {
            // ...
        }

        /**
         * Bootstrap any application services.
         */
        public function boot(): void
        {
            JsonResource::withoutWrapping();
        }
    }

Il metodo withoutWrapping influisce solo sulla risposta più esterna e non rimuoverà le chiavi data che aggiungi manualmente alle tue collezioni di risorse.

Wrapping Nested Resources

Hai piena libertà di determinare come avvolgere le relazioni delle tue risorse. Se desideri che tutte le collezioni di risorse siano incapsulate in una chiave data, indipendentemente dalla loro annidazione, dovresti definire una classe di collezione risorse per ogni risorsa e restituire la collezione all’interno di una chiave data.

Potresti chiederti se questo farà sì che la tua risorsa più esterna sia avvolta in due chiavi data. Non preoccuparti, Laravel non permetterà mai che le tue risorse siano accidentalmente avvolte due volte, quindi non devi preoccuparti del livello di annidamento della collezione di risorse che stai trasformando:

    <?php

    namespace App\Http\Resources;

    use Illuminate\Http\Resources\Json\ResourceCollection;

    class CommentsCollection extends ResourceCollection
    {
        /**
         * Trasforma la collezione di risorse in un array.
         *
         * @return array<string, mixed>
         */
        public function toArray(Request $request): array
        {
            return ['data' => $this->collection];
        }
    }

Involucro dei Dati e Paginazione

Quando si restituiscono collezioni paginati tramite una risposta di risorsa, Laravel avvolgerà i dati della risorsa in una chiave data anche se è stato chiamato il metodo withoutWrapping. Questo perché le risposte paginate contengono sempre le chiavi meta e links con informazioni sullo stato del paginator:

{
    "data": [
        {
            "id": 1,
            "name": "Eladio Schroeder Sr.",
            "email": "therese28@example.com"
        },
        {
            "id": 2,
            "name": "Liliana Mayert",
            "email": "evandervort@example.com"
        }
    ],
    "links":{
        "first": "http://example.com/users?page=1",
        "last": "http://example.com/users?page=1",
        "prev": null,
        "next": null
    },
    "meta":{
        "current_page": 1,
        "from": 1,
        "last_page": 1,
        "path": "http://example.com/users",
        "per_page": 15,
        "to": 10,
        "total": 10
    }
}

Paginazione

Puoi passare un’istanza paginator di Laravel al metodo collection di una risorsa o a una collezione di risorse personalizzata:

    use App\Http\Resources\UserCollection;
    use App\Models\User;

    Route::get('/users', function () {
        return new UserCollection(User::paginate());
    });

Le risposte con paginazione contengono sempre le chiavi meta e links con informazioni sullo stato del paginator:

{
    "data": [
        {
            "id": 1,
            "name": "Eladio Schroeder Sr.",
            "email": "therese28@example.com"
        },
        {
            "id": 2,
            "name": "Liliana Mayert",
            "email": "evandervort@example.com"
        }
    ],
    "links":{
        "first": "http://example.com/users?page=1",
        "last": "http://example.com/users?page=1",
        "prev": null,
        "next": null
    },
    "meta":{
        "current_page": 1,
        "from": 1,
        "last_page": 1,
        "path": "http://example.com/users",
        "per_page": 15,
        "to": 10,
        "total": 10
    }
}

Personalizzare le Informazioni di Paginazione

Se desideri personalizzare le informazioni incluse nelle chiavi links o meta della risposta di paginazione, puoi definire un metodo paginationInformation sulla risorsa. Questo metodo riceve i dati $paginated e l’array delle informazioni $default, che è un array contenente le chiavi links e meta:

    /**
     * Personalizza le informazioni di paginazione per la risorsa.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  array $paginated
     * @param  array $default
     * @return array
     */
    public function paginationInformation($request, $paginated, $default)
    {
        $default['links']['custom'] = 'https://example.com';

        return $default;
    }

Attributi Condizionali

A volte potresti voler includere un attributo nella risposta di una risorsa solo se una determinata condizione è soddisfatta. Ad esempio, potresti voler includere un valore solo se l’utente corrente è un "amministratore". Laravel fornisce diversi metodi helper per assisterti in questa situazione. Il metodo when può essere usato per aggiungere condizionatamente un attributo alla risposta di una risorsa:

/**
 * Trasforma la risorsa in un array.
 *
 * @return array<string, mixed>
 */
public function toArray(Request $request): array
{
    return [
        'id' => $this->id,
        'name' => $this->name,
        'email' => $this->email,
        'secret' => $this->when($request->user()->isAdmin(), 'secret-value'),
        'created_at' => $this->created_at,
        'updated_at' => $this->updated_at,
    ];
}

In questo esempio, la chiave secret verrà restituita nella risposta finale della risorsa solo se il metodo isAdmin dell’utente autenticato restituisce true. Se il metodo restituisce false, la chiave secret verrà rimossa dalla risposta della risorsa prima di essere inviata al client. Il metodo when ti permette di definire in modo espressivo le tue risorse senza dover ricorrere a istruzioni condizionali durante la costruzione dell’array.

Il metodo when accetta anche una closure come secondo argomento, permettendoti di calcolare il valore risultante solo se la condizione data è true:

'secret' => $this->when($request->user()->isAdmin(), function () {
    return 'secret-value';
}),

Il metodo whenHas può essere usato per includere un attributo se è effettivamente presente sul modello sottostante:

'name' => $this->whenHas('name'),

Inoltre, il metodo whenNotNull può essere usato per includere un attributo nella risposta della risorsa se l’attributo non è nullo:

'name' => $this->whenNotNull($this->name),

Unire Attributi Condizionali

A volte potresti avere diversi attributi che devono essere inclusi nella risposta della risorsa solo se viene soddisfatta la stessa condizione. In questo caso, puoi usare il metodo mergeWhen per includere gli attributi nella risposta solo quando la condizione data è true:

    /**
     * Trasforma la risorsa in un array.
     *
     * @return array<string, mixed>
     */
    public function toArray(Request $request): array
    {
        return [
            'id' => $this->id,
            'name' => $this->name,
            'email' => $this->email,
            $this->mergeWhen($request->user()->isAdmin(), [
                'first-secret' => 'value',
                'second-secret' => 'value',
            ]),
            'created_at' => $this->created_at,
            'updated_at' => $this->updated_at,
        ];
    }

Se la condizione data è false, questi attributi verranno rimossi dalla risposta della risorsa prima di essere inviati al client.

Il metodo mergeWhen non dovrebbe essere usato all’interno di array che mescolano chiavi stringa e numeriche. Inoltre, non dovrebbe essere usato in array con chiavi numeriche che non sono ordinate sequenzialmente.

Relazioni Condizionali

Oltre a caricare attributi in modo condizionale, puoi includere relazioni nelle risposte delle tue risorse in base al fatto che la relazione sia già stata caricata sul modello. Questo permette al tuo controller di decidere quali relazioni caricare sul modello e alla tua risorsa di includerle solo quando sono effettivamente state caricate. In definitiva, questo facilita l’evitare problemi di query "N+1" all’interno delle tue risorse.

Il metodo whenLoaded può essere utilizzato per caricare una relazione in modo condizionale. Per evitare di caricare relazioni inutilmente, questo metodo accetta il nome della relazione invece della relazione stessa:

use App\Http\Resources\PostResource;

/**
 * Trasforma la risorsa in un array.
 *
 * @return array<string, mixed>
 */
public function toArray(Request $request): array
{
    return [
        'id' => $this->id,
        'name' => $this->name,
        'email' => $this->email,
        'posts' => PostResource::collection($this->whenLoaded('posts')),
        'created_at' => $this->created_at,
        'updated_at' => $this->updated_at,
    ];
}

In questo esempio, se la relazione non è stata caricata, la chiave posts verrà rimossa dalla risposta della risorsa prima di essere inviata al cliente.

Conteggi Condizionali delle Relazioni

Oltre a includere relazioni in modo condizionale, puoi includere condizionalmente i "conteggi" delle relazioni nelle risposte delle tue risorse in base al fatto che il conteggio della relazione sia stato caricato sul modello:

    new UserResource($user->loadCount('posts'));

Il metodo whenCounted può essere utilizzato per includere condizionalmente il conteggio di una relazione nella tua risposta risorsa. Questo metodo evita di includere inutilmente l’attributo se il conteggio delle relazioni non è presente:

    /**
     * Trasforma la risorsa in un array.
     *
     * @return array<string, mixed>
     */
    public function toArray(Request $request): array
    {
        return [
            'id' => $this->id,
            'name' => $this->name,
            'email' => $this->email,
            'posts_count' => $this->whenCounted('posts'),
            'created_at' => $this->created_at,
            'updated_at' => $this->updated_at,
        ];
    }

In questo esempio, se il conteggio della relazione posts non è stato caricato, la chiave posts_count verrà rimossa dalla risposta della risorsa prima di essere inviata al client.

Altri tipi di aggregati, come avg, sum, min e max, possono essere caricati condizionalmente utilizzando il metodo whenAggregated:

'words_avg' => $this->whenAggregated('posts', 'words', 'avg'),
'words_sum' => $this->whenAggregated('posts', 'words', 'sum'),
'words_min' => $this->whenAggregated('posts', 'words', 'min'),
'words_max' => $this->whenAggregated('posts', 'words', 'max'),

Informazioni Pivot Condizionali

Oltre a includere condizionalmente le informazioni sulla relazione nelle risposte delle tue risorse, puoi includere condizionalmente i dati dalle tabelle intermedie delle relazioni molti-a-molti utilizzando il metodo whenPivotLoaded. Il metodo whenPivotLoaded accetta il nome della tabella pivot come primo argomento. Il secondo argomento deve essere una closure che restituisce il valore da restituire se le informazioni pivot sono disponibili sul modello:

/**
 * Trasforma la risorsa in un array.
 *
 * @return array<string, mixed>
 */
public function toArray(Request $request): array
{
    return [
        'id' => $this->id,
        'name' => $this->name,
        'expires_at' => $this->whenPivotLoaded('role_user', function () {
            return $this->pivot->expires_at;
        }),
    ];
}

Se la tua relazione utilizza un modello di tabella intermedia personalizzato, puoi passare un’istanza del modello della tabella intermedia come primo argomento al metodo whenPivotLoaded:

'expires_at' => $this->whenPivotLoaded(new Membership, function () {
    return $this->pivot->expires_at;
}),

Se la tua tabella intermedia utilizza un accessor diverso da pivot, puoi usare il metodo whenPivotLoadedAs:

/**
 * Trasforma la risorsa in un array.
 *
 * @return array<string, mixed>
 */
public function toArray(Request $request): array
{
    return [
        'id' => $this->id,
        'name' => $this->name,
        'expires_at' => $this->whenPivotLoadedAs('subscription', 'role_user', function () {
            return $this->subscription->expires_at;
        }),
    ];
}

Aggiungere Meta Dati

Alcuni standard JSON API richiedono l’aggiunta di meta dati alle risposte delle tue risorse e collezioni di risorse. Questo spesso include elementi come i links alla risorsa o a risorse correlate, oppure meta dati sulla risorsa stessa. Se hai bisogno di restituire meta dati aggiuntivi su una risorsa, includili nel tuo metodo toArray. Ad esempio, potresti includere informazioni links quando trasformi una collezione di risorse:

/**
 * Transform the resource into an array.
 *
 * @return array<string, mixed>
 */
public function toArray(Request $request): array
{
    return [
        'data' => $this->collection,
        'links' => [
            'self' => 'link-value',
        ],
    ];
}

Quando restituisci meta dati aggiuntivi dalle tue risorse, non devi preoccuparti di sovrascrivere accidentalmente le chiavi links o meta che Laravel aggiunge automaticamente quando restituisci risposte paginate. Qualsiasi links aggiuntivo che definisci sarà unito ai link forniti dal paginator.

Metadati di Livello Superiore

A volte potresti voler includere solo alcuni metadati nella risposta di una risorsa se la risorsa è la risorsa più esterna che viene restituita. Tipicamente, questo include informazioni meta sulla risposta nel suo complesso. Per definire questi metadati, aggiungi un metodo with alla tua classe di risorsa. Questo metodo dovrebbe restituire un array di metadati da includere nella risposta della risorsa solo quando la risorsa è la risorsa più esterna che viene trasformata:

<?php

namespace App\Http\Resources;

use Illuminate\Http\Resources\Json\ResourceCollection;

class UserCollection extends ResourceCollection
{
    /**
     * Trasforma la collezione di risorse in un array.
     *
     * @return array<string, mixed>
     */
    public function toArray(Request $request): array
    {
        return parent::toArray($request);
    }

    /**
     * Ottieni dati aggiuntivi che dovrebbero essere restituiti con l'array della risorsa.
     *
     * @return array<string, mixed>
     */
    public function with(Request $request): array
    {
        return [
            'meta' => [
                'key' => 'value',
            ],
        ];
    }
}

Aggiungere Meta Dati Durante la Costruzione delle Risorse

Puoi anche aggiungere dati di livello superiore durante la costruzione delle istanze delle risorse nel tuo route o controller. Il metodo additional, disponibile su tutte le risorse, accetta un array di dati che devono essere aggiunti alla risposta della risorsa:

return (new UserCollection(User::all()->load('roles')))
                ->additional(['meta' => [
                    'key' => 'value',
                ]]);

Risposte delle Risorse

Come hai già letto, le risorse possono essere restituite direttamente dalle rotte e dai controller:

use App\Http\Resources\UserResource;
use App\Models\User;

Route::get('/user/{id}', function (string $id) {
    return new UserResource(User::findOrFail($id));
});

Tuttavia, a volte potresti aver bisogno di personalizzare la risposta HTTP in uscita prima che venga inviata al client. Ci sono due modi per farlo. Prima, puoi concatenare il metodo response sulla risorsa. Questo metodo restituirà un’istanza di Illuminate\Http\JsonResponse, dandoti pieno controllo sugli header della risposta:

use App\Http\Resources\UserResource;
use App\Models\User;

Route::get('/user', function () {
    return (new UserResource(User::find(1)))
                ->response()
                ->header('X-Value', 'True');
});

In alternativa, puoi definire un metodo withResponse all’interno della risorsa stessa. Questo metodo verrà chiamato quando la risorsa viene restituita come risorsa più esterna in una risposta:

<?php

namespace App\Http\Resources;

use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Illuminate\Http\Resources\Json\JsonResource;

class UserResource extends JsonResource
{
    /**
     * Trasforma la risorsa in un array.
     *
     * @return array<string, mixed>
     */
    public function toArray(Request $request): array
    {
        return [
            'id' => $this->id,
        ];
    }

    /**
     * Personalizza la risposta in uscita per la risorsa.
     */
    public function withResponse(Request $request, JsonResponse $response): void
    {
        $response->header('X-Value', 'True');
    }
}
Lascia un commento

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *

Laravel-Italia.it è il sito della Community Italiana di Laravel.
2024 — Laravel-Italia