Laravel Eloquent è uno strumento semplice per interagire con un database. È un object-relational mapper (ORM) che semplifica la complessità dei database offrendo un modello per interagire con le tabelle.

Per questo motivo, Laravel Eloquent dispone di strumenti eccellenti per creare e testare le API a supporto dello sviluppo. In questo articolo tutorial, vedremo come è facile creare e testare le API con Laravel.

In questa dimostrazione, inizieremo con la creazione di un modello da usare per costruire l’API e la tabella del database. Poi vedremo come aggiungere un controller come livello di logica aziendale e una route per completare l’API. Impareremo poi a testare le API con Postman prima di concentrarci sull’autenticazione e sulla gestione degli errori.

Prerequisiti

Ecco cosa serve per iniziare:

Nozioni di base sulle API

Iniziate creando un nuovo progetto Laravel con composer:

composer create-project laravel/laravel laravel-api-create-test

Per avviare il server, lanciate il seguente comando, che esegue l’application server sulla porta 8000:

cd laravel-api-create-test
php artisan serve

Dovreste vedere la seguente schermata:

Schermata iniziale di Laravel
Laravel

Quindi, create un modello con un flag -m per la migrazione utilizzando il codice seguente:

php artisan make:model Product -m

Ora aggiornate il file di migrazione per includere il campo richiesto. Aggiungete i campi titolo e descrizione per il modello del prodotto e questi due campi della tabella all’interno del file database/migrations/{date_stamp}_create_products_table.php.

$table->string('title');
$table->longText('description');

Il passo successivo è rendere questi campi compilabili. All’interno di app/Models/Product.php, rendete compilabili i campi title e description.

protected $fillable = ['title', 'description'];

Come creare un controller

Ora create un file controller per il prodotto eseguendo il seguente comando. In questo modo verrà creato il file app/Http/Controllers/Api/ProductController.php.

php artisan make:controller ApiProductController --model=Product

Ora, aggiungete la logica per creare e recuperare i prodotti. All’interno del metodo index, aggiungete il seguente codice per recuperare tutti i prodotti:

$products = Product::all();
return response()->json([
	'status' => true,
	'products' => $products
]);

Poi dovete aggiungere una classe StoreProductRequest per memorizzare i nuovi prodotti nel database. Aggiungete la seguente classe all’inizio dello stesso file.

public function store(StoreProductRequest $request)
 {
	$product = Product::create($request->all());

	return response()->json([
    	'status' => true,
    	'message' => "Product Created successfully!",
    	'product' => $product
	], 200);
 }

Ora dovrete creare la richiesta eseguendo questo comando:

php artisan make:request StoreProductRequest

Se volete aggiungere delle convalide, potete usare il file app/Http/Requests/StoreProductRequest.php. Per questa dimostrazione non ci sono convalide.

Come creare una route

L’ultimo passo da fare prima di testare l’API è aggiungere una route. Per farlo, aggiungete il seguente codice all’interno del file routes/api.php. Aggiungete l’istruzione use all’inizio del file e l’istruzione Route nel corpo:

use AppHttpControllersApiProductController;
Route::apiResource('products', ProductController::class);

Prima di iniziare a testare l’API, verificate che la tabella dei prodotti sia presente nel vostro database. Se non esiste, createla usando un pannello di controllo come XAMPP. In alternativa, potete eseguire il comando qui sotto per migrare il database:

php artisan migrate

Come testare un’API

Prima di testare l’API, assicuratevi che il metodo authorize all’interno dell’app/Http/Requests/StoreProductRequest.php sia impostato per restituire true.

Ora potete creare un nuovo prodotto utilizzando Postman. Iniziate con una richiesta POST a questo URL: http://127.0.0.1:8000/api/products/. Poiché si tratta di una richiesta POST per creare un nuovo prodotto, dovete passare un oggetto JSON con un titolo e una descrizione.

{
	"title":"Apple",
	"description":"Best Apples of the world"
}
Schermata di Postman con la schermata per creare un nuovo prodotto
Creare un nuovo prodotto in Postman

Dopo aver fatto clic sul pulsante Send, dovreste vedere quanto segue:

Schermata di Postman con l’output dopo aver fatto clic su Send
Dopo aver fatto clic su Send

Ora recuperate i prodotti creati utilizzando la richiesta GET. L’URL è lo stesso. I risultati saranno i seguenti:

Schermata di Postman con i prodotti recuperati con la richiesta GET.
I prodotti recuperati con la richiesta GET.

Come autenticare un’API con Sanctum

L’autenticazione è fondamentale per proteggere un’API. Laravel la semplifica fornendo la funzionalità del token Sanctum, che potete usare come middleware. L’API è protetta da token generati quando l’utente accede utilizzando le credenziali corrette. Ricordate che gli utenti non possono accedere all’API protetta senza un token.

Il primo passo per aggiungere l’autenticazione è aggiungere un pacchetto Sanctum con il codice sottostante:

composer require laravel/sanctum

Quindi pubblicate il file di configurazione di Sanctum:

php artisan vendor:publish --provider="LaravelSanctumSanctumServiceProvider"

Successivamente, aggiungete il token di Sanctum come middleware. All’interno del file app/Http/Kernel.php, usate la seguente classe e sostituite middlewareGroups con il seguente codice nelle API protette dei gruppi middleware.

use LaravelSanctumHttpMiddlewareEnsureFrontendRequestsAreStateful;
protected $middlewareGroups = [
	'web' => [
    	AppHttpMiddlewareEncryptCookies::class,
    	IlluminateCookieMiddlewareAddQueuedCookiesToResponse::class,
    	IlluminateSessionMiddlewareStartSession::class,
    	// IlluminateSessionMiddlewareAuthenticateSession::class,
    	IlluminateViewMiddlewareShareErrorsFromSession::class,
    	AppHttpMiddlewareVerifyCsrfToken::class,
    	IlluminateRoutingMiddlewareSubstituteBindings::class,
	],

	'api' => [
    	EnsureFrontendRequestsAreStateful::class,
    	'throttle:api',
    	IlluminateRoutingMiddlewareSubstituteBindings::class,
	],
];

Il passo successivo è creare un UserController e aggiungere il codice per ottenere il token di autenticazione.

php artisan make:controller UserController

Dopo aver creato UserController, andate al file app/Http/Controllers/UserController.php e sostituite il codice esistente con il seguente:

<?php

namespace AppHttpControllers;

use IlluminateHttpRequest;
use AppModelsUser;
use IlluminateSupportFacadesHash;
class UserController extends Controller
{
	//

	function index(Request $request)
	{
    	$user= User::where('email', $request->email)->first();
    	// print_r($data);
        	if (!$user || !Hash::check($request->password, $user->password)) {
            	return response([
                	'message' => ['These credentials do not match our records.']
            	], 404);
        	}
   	 
         	$token = $user->createToken('my-app-token')->plainTextToken;
   	 
        	$response = [
            	'user' => $user,
            	'token' => $token
        	];
   	 
         	return response($response, 201);
	}
}

Prima di testare l’autenticazione, create un utente che impiega i seeders. Il comando seguente crea un file UsersTableSeeder.

php artisan make:seeder UsersTableSeeder

All’interno del file database/seeders/UsersTableSeeder.php, sostituite il codice esistente con il seguente per creare l’utente:

<?php

namespace DatabaseSeeders;

use IlluminateDatabaseSeeder;
use IlluminateSupportFacadesDB;
use IlluminateSupportFacadesHash;

class UsersTableSeeder extends Seeder
{
	/**
 	* Run the database seeds.
 	*
 	* @return void
 	*/
	public function run()
	{
    	DB::table('users')->insert([
        	'name' => 'John Doe',
        	'email' => '[email protected]',
        	'password' => Hash::make('password')
    	]);
	}
}

Ora eseguite il seeder utilizzando questo comando:

php artisan db:seed --class=UsersTableSeeder

L’ultimo passo rimasto nel flusso di autenticazione è quello di usare il middleware creato per proteggere il percorso. Andate al file routes/api.php e aggiungete la route products all’interno del middleware.

use AppHttpControllersUserController;

Route::group(['middleware' => 'auth:sanctum'], function () {
	Route::apiResource('products', ProductController::class);
});

Route::post("login",[UserController::class,'index']);

Dopo aver aggiunto una route al middleware, otterrete un errore interno del server se cercate di recuperare i prodotti.

Schermata di Postman con un messaggio di internal server error dopo aver aggiunto una route
Un errore interno del server dopo aver aggiunto una route

Ma una volta che avrete fatto la connessione, ottenuto un token da usare nell’header, il sistema vi autenticherà e inizierà a funzionare. Potete inviare una richiesta POST a http://127.0.0.1:8000/api/login con il seguente corpo:

{
	"email":"[email protected]",
	"password":"password"
}
Schermata di Postman con l’output di avvenuta autenticazione e il token Bearer
Autenticazione riuscita

Usate il token ricevuto come token Bearer e aggiungetelo all’header Authorization.

Schermata di Postman con i comandi per aggiungere il token Bearer come header Authorization
Aggiungere il token Bearer come header Authorization

Come gestire gli errori API

Ogni volta che inviate una richiesta al server, questo risponde. Con la risposta, invia anche un codice di stato in base alla natura della risposta. Per esempio, un codice di stato 200 indica che la richiesta è andata a buon fine, mentre un 404 indica che il server non riesce a trovare la risorsa richiesta.

Tuttavia, un codice di stato non è sufficiente. È necessario un messaggio di errore leggibile dall’occhio umano. Laravel offre molti modi per gestire gli errori. Potete usare un blocco try-catch, il metodo fallback o inviare una risposta personalizzata. Il seguente codice aggiunto a UserController ne è la dimostrazione.

if (!$user || !Hash::check($request->password, $user->password)) {
	return response([
    	'message' => ['These credentials do not match our records.']
	], 404);
}

Riepilogo

L’Eloquent Model di Laravel facilita la creazione, validazione e test delle API. La sua mappatura oggetto-relazionale fornisce un approccio semplice all’interazione con il database.

Inoltre, agendo come middleware, il token Sanctum di Laravel può aiutarvi a proteggere rapidamente le vostre API.

E se avete bisogno di un’ulteriore ottimizzazione, la soluzione Hosting di Database di Kinsta semplifica l’impostazione e la gestione dei database per tutti i vostri progetti web.

Jeremy Holcombe Kinsta

Content & Marketing Editor at Kinsta, WordPress Web Developer, and Content Writer. Outside of all things WordPress, I enjoy the beach, golf, and movies. I also have tall people problems ;).