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á:

Noções básicas de API

Comece criando um novo projeto Laravel usando composer:

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

Para iniciar o servidor, execute o seguinte comando, que roda o servidor de aplicativos na porta 8000:

cd laravel-api-create-test
php artisan serve

Você deverá ver a tela a seguir:

A página de destino do Laravel
Laravel.

Em seguida crie um modelo com um flag -m para a migração usando o código abaixo:

php artisan make:model Product -m

Agora 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=Product

Adicione 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 StoreProductRequest

Se 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 migrate

Como 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"
}
Criando um novo produto no Postman.
Criando um novo produto no Postman.

Depois de clicar no botão Send (Enviar), você deverá ver o seguinte:

Após clicar em Send.
Após clicar em Send.

Agora busque os produtos criados usando a solicitação GET. A URL é a mesma. Os resultados serão parecidos com os seguintes:

Os produtos obtidos pela solicitação GET.
Os produtos obtidos pela solicitação GET.

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/sanctum

Daí 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 UserController

Apó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 UsersTableSeeder

Dentro 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=UsersTableSeeder

A ú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.

Um erro interno do servidor após adicionar uma rota.
Um erro interno do servidor após adicionar uma rota.

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"
}
Autenticação bem-sucedida.
Autenticação bem-sucedida.

Use o token recebido como um token bearer e o adicione como cabeçalho de autorização.

Adicionando o token bearer como cabeçalho de autorização.
Adicionando o token bearer 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.

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