O Laravel Eloquent é uma maneira fácil de interagir com seu banco de dados. É um mapeador objeto-relacional (ORM) que simplifica as complexidades dos bancos de dados, fornecendo um modelo para interagir com as tabelas.
Como tal, o Laravel Eloquent tem excelentes ferramentas para criar e testar APIs para dar suporte ao seu desenvolvimento. Neste artigo prático, você verá como é fácil criar e testar APIs usando o Laravel.
Nesta demonstração, você começará criando um modelo que pode ser usado para criar a API e a tabela do banco de dados. Daí verá como adicionar um controlador como camada de lógica de negócios e uma rota para concluir a API. Em seguida, você aprenderá a realizar testes de APIs usando o Postman antes de finalmente se concentrar na autenticação e no tratamento de erros.
Pré-requisitos
Para começar, eis o que você precisará:
- Laravel versão 8 ou 9
- Composer
- Postman
- XAMPP
- Conhecimento básico de APIs e PHP
Noções básicas de API
Comece criando um novo projeto Laravel usando composer:
composer create-project laravel/laravel laravel-api-create-testPara iniciar o servidor, execute o seguinte comando, que roda o servidor de aplicativos na porta 8000:
cd laravel-api-create-test
php artisan serveVocê deverá ver a tela a seguir:
Em seguida crie um modelo com um flag -m para a migração usando o código abaixo:
php artisan make:model Product -mAgora atualize o arquivo de migração para incluir o campo obrigatório. Adicione os campos de título e descrição para o modelo de produto e esses dois campos de tabela dentro do arquivo database/migrations/{date_stamp}_create_products_table.php.
$table->string('title');
$table->longText('description');A próxima etapa é tornar esses campos preenchíveis. Dentro de app/Models/Product.php, torne os campos title e description preenchíveis.
protected $fillable = ['title', 'description'];Como criar um controlador
Agora crie um arquivo controlador para o produto executando o seguinte comando, que criará o arquivo app/Http/Controllers/Api/ProductController.php:
php artisan make:controller ApiProductController --model=ProductAdicione a lógica para criar e recuperar os produtos. Dentro do método index, adicione o seguinte código para recuperar todos os produtos:
$products = Product::all();
return response()->json([
'status' => true,
'products' => $products
]);Depois disso, você deve adicionar uma classe StoreProductRequest para armazenar os novos produtos no banco de dados. Adicione a seguinte classe na parte superior do mesmo arquivo.
public function store(StoreProductRequest $request)
{
$product = Product::create($request->all());
return response()->json([
'status' => true,
'message' => "Product Created successfully!",
'product' => $product
], 200);
}Então crie a solicitação, executando o seguinte comando:
php artisan make:request StoreProductRequestSe quiser adicionar validações, você pode usar o arquivo app/Http/Requests/StoreProductRequest.php. Para esta demonstração, não há validações.
Como criar uma rota
A etapa final antes de testar a API é adicionar uma rota. Para isso, adicione o seguinte código no arquivo routes/api.php. Adicione a instrução use no início do arquivo e a instrução Route no corpo:
use AppHttpControllersApiProductController;
Route::apiResource('products', ProductController::class);Antes começar a testar a API, certifique-se de que a tabela de produtos esteja em seu banco de dados. Se ela não existir, crie uma usando um painel de controle como o XAMPP. Como alternativa, você pode executar o seguinte comando para migrar o banco de dados:
php artisan migrateComo testar uma API
Antes de testar a API, verifique se o método authorize dentro de app/Http/Requests/StoreProductRequest.php está definido para retornar true.
Agora você pode criar um novo produto usando o Postman. Comece fazendo uma solicitação POST para esta URL: http://127.0.0.1:8000/api/products/. Como se trata de uma solicitação POST para criar um novo produto, você deve passar um objeto JSON com um título e uma descrição.
{
"title":"Apple",
"description":"Best Apples of the world"
}
Depois de clicar no botão Send (Enviar), você deverá ver o seguinte:
Agora busque os produtos criados usando a solicitação GET. A URL é a mesma. Os resultados serão parecidos com os seguintes:
Como autenticar uma API usando o Sanctum
A autenticação é crucial quando você está protegendo uma API. O Laravel facilita isso fornecendo a funcionalidade do token Sanctum, que você pode usar como middleware. Ele protege a API usando tokens gerados quando o usuário faz login com as credenciais corretas. Lembre-se de que os usuários não podem acessar a API protegida sem um token.
A primeira etapa para adicionar a autenticação é adicionar um pacote Sanctum usando o código abaixo:
composer require laravel/sanctumDaí publique o arquivo de configuração do Sanctum:
php artisan vendor:publish --provider="LaravelSanctumSanctumServiceProvider"Depois disso, adicione o token do Sanctum como middleware. Dentro do arquivo app/Http/Kernel.php, use a seguinte classe e substitua middlewareGroups pelo seguinte código na API dos grupos de middleware protegidos.
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,
],
];O próximo passo é criar um UserController e adicionar o código para obter o token para autenticação.
php artisan make:controller UserControllerApós criar o UserController, navegue até o arquivo app/Http/Controllers/UserController.php e substitua o código existente pelo código a seguir:
<?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);
}
}Antes que você possa testar a autenticação, crie um usuário empregando seeders. O comando a seguir cria um arquivo UsersTableSeeder.
php artisan make:seeder UsersTableSeederDentro do arquivo database/seeders/UsersTableSeeder.php, substitua o código existente pelo código a seguir para propagar o usuário:
<?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')
]);
}
}Agora execute o seeder usando este comando:
php artisan db:seed --class=UsersTableSeederA última etapa que falta no fluxo de autenticação é usar o middleware criado para proteger a rota. Navegue até o arquivo routes/api.php e adicione a rota de produtos dentro do middleware.
use AppHttpControllersUserController;
Route::group(['middleware' => 'auth:sanctum'], function () {
Route::apiResource('products', ProductController::class);
});
Route::post("login",[UserController::class,'index']);Depois de adicionar uma rota ao middleware, você receberá um erro interno do servidor se tentar buscar os produtos.
Mas quando você fizer login, obtiver um token e usá-lo no cabeçalho, ele autenticará você e começará a funcionar. Você pode enviar uma solicitação POST para http://127.0.0.1:8000/api/login com o seguinte corpo:
{
"email":"[email protected]",
"password":"password"
}
Use o token recebido como um token bearer e o adicione como cabeçalho de autorização.
Como lidar com erros de API
Sempre que você envia uma solicitação ao servidor, ele responde. Com a resposta, ele também envia um código de status de acordo com a natureza da resposta. Por exemplo, um código de status 200 indica que a solicitação foi bem-sucedida, e um 404 sugere que o servidor não consegue encontrar o recurso solicitado.
No entanto, um código de status não é suficiente. Você precisa de uma mensagem de erro legível por humanos. O Laravel oferece muitas maneiras de lidar com erros. Você pode usar um bloco try-catch, o método fallback ou enviar uma resposta personalizada. O código a seguir que você adicionou ao site UserController demonstra isso.
if (!$user || !Hash::check($request->password, $user->password)) {
return response([
'message' => ['These credentials do not match our records.']
], 404);
}Resumo
O Eloquent Model do Laravel facilita a criação, a validação e o teste de APIs. Seu mapeamento objeto-relacional oferece uma abordagem direta para interagir com o banco de dados.
Além disso, atuando como middleware, o token Sanctum do Laravel pode ajudar você a proteger suas APIs rapidamente.
E se você precisar de mais otimização, a solução de hospedagem de banco de dados da Kinsta simplifica a configuração e o gerenciamento de bancos de dados para todos os seus projetos da web.
Deixe um comentário