Criando uma API de Mini Blog com Lithe e Eloquent

Neste tutorial, vamos criar uma API de Mini Blog utilizando o Lithe, um framework PHP que é simples e flexível, e o Eloquent ORM, que facilita a interação com o banco de dados. O Lithe já configura o Eloquent automaticamente, então o trabalho que precisamos fazer é simples: ajustar as variáveis de ambiente e criar o modelo e a migração para nossos dados.

Vamos seguir um passo a passo simples para construir essa API de forma eficiente e sem complicação.

Passo 1: Instalar o Lithe

O primeiro passo é instalar o Lithe no seu projeto. Se ainda não fez isso, basta rodar o seguinte comando no terminal:

composer create-project lithephp/lithephp mini-blog-api

Este comando cria um novo projeto usando o Lithe. O Lithe já configura o Eloquent para você automaticamente, mas precisamos ajustar algumas configurações no arquivo .env para conectar ao banco de dados.

Passo 2: Configurar o Banco de Dados

Agora, vamos configurar o banco de dados. Abra o arquivo .env na raiz do seu projeto e edite as configurações de banco de dados. Para usar o Eloquent ORM com MySQL, as configurações devem ser assim:

DB_CONNECTION_METHOD=eloquent
DB_CONNECTION=mysql
DB_HOST=localhost
DB_NAME=lithe_eloquent
DB_USERNAME=root
DB_PASSWORD=
DB_SHOULD_INITIATE=true

Agora, como o Lithe já configura automaticamente o Eloquent, o próximo passo é garantir que o Eloquent ORM esteja instalado. Caso ainda não tenha feito isso, execute o comando abaixo para instalar o Eloquent ORM:

composer require illuminate/database

Após a instalação, o Lithe já estará pronto para usar o Eloquent ORM e interagir com o banco de dados. Com isso, o banco de dados está configurado corretamente para nossa API de Mini Blog!

Passo 3: Criar o Modelo e Migração para os Posts

Agora, vamos criar o modelo e a migração que vão definir a tabela de posts no nosso banco de dados.

Primeiro, crie o modelo Post com o comando:

php line make:model Post

Depois, crie a migração para a tabela posts:

php line make:migration create_posts_table

O modelo e a migração já foram criados, agora vamos configurá-los.

Modelo Post

O modelo Post fica em src/models/Post.php. Edite o arquivo assim:

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Post extends Model
{
    // A tabela associada ao modelo
    protected $table = 'posts';

    // Campos que podem ser preenchidos via mass-assignment
    protected $fillable = ['title', 'content'];

    // Usar timestamps para created_at e updated_at
    public $timestamps = true;
}

Neste código, estamos definindo os campos title e content como preenchíveis, ou seja, eles podem ser preenchidos automaticamente quando criamos ou atualizamos um post.

Migração da Tabela Posts

A migração gerada vai estar em src/database/migrations/{timestamp}_create_posts_table.php. Edite a migração para criar a estrutura da tabela posts:

use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Capsule\Manager as Capsule;

return new class
{
    public function up(): void
    {
         Capsule::schema()->create('posts', function (Blueprint $table) {
            $table->id(); // Cria o campo id auto-increment
            $table->string('title'); // Cria o campo title (Título do post)
            $table->text('content'); // Cria o campo content (Conteúdo do post)
            $table->timestamps(); // Cria os campos created_at e updated_at
        });
    }

    public function down(): void
    {
         Capsule::schema()->dropIfExists('posts');
    }
};

Aqui, estamos criando a tabela posts com os campos id, title, content, e os campos de data e hora created_at e updated_at.

Passo 4: Rodar a Migração

Com a migração e o modelo prontos, vamos rodar a migração para criar a tabela posts no banco de dados. Execute o seguinte comando:

php line migrate

Esse comando vai criar a tabela posts no banco de dados com os campos que definimos na migração.

Passo 5: Criar o Controller para Posts

Agora, vamos criar um controller para gerenciar os posts da API. O controller será responsável por lidar com as requisições HTTP e retornar os dados de forma organizada.

Para criar o controller, execute:

php line make:controller PostController

Isso vai gerar um arquivo em src/http/Controllers/PostController.php. Edite esse arquivo para incluir os métodos de CRUD (criação, leitura, atualização e exclusão) para os posts.

Aqui está um exemplo de como o PostController pode ficar:

namespace App\Http\Controllers;

use App\Models\Post;
use Lithe\Http\Request;
use Lithe\Http\Response;

class PostController
{
    // Listar todos os posts
    public function index(Request $req, Response $res)
    {
        $posts = Post::all(); // Retorna todos os posts
        return $res->json($posts);
    }

    // Mostrar um post específico
    public function show(Request $req, Response $res)
    {
        $id = $req->param('id');

        $post = Post::find($id); // Encontra o post pelo ID
        return $res->json($post);
    }

    // Criar um novo post
    public function store(Request $req, Response $res)
    {
        $data = (array) $req->body(); // Obtém os dados da requisição

        $post = Post::create($data); // Cria um novo post
        return $res->status(201)->json($post); // Retorna o post criado com status 201
    }

    // Atualizar um post existente
    public function update(Request $req, Response $res)
    {
        $id = $req->param('id');

        $data = (array) $req->body(); // Dados da requisição
        $post = Post::find($id); // Encontra o post pelo ID

        if ($post) {
            $post->update($data); // Atualiza o post
            return $res->json($post);
        }

        return $res->status(404)->json(['message' => 'Post não encontrado']);
    }

    // Deletar um post
    public function destroy(Request $req, Response $res)
    {
        $id = $req->param('id');
        $post = Post::find($id);

        if ($post) {
            $post->delete(); // Deleta o post
            return $res->json(['message' => 'Post deletado']);
        }

        return $res->status(404)->json(['message' => 'Post não encontrado']);
    }
}

Aqui, temos cinco métodos básicos:

index: Lista todos os posts.
show: Exibe um post específico.
store: Cria um novo post.
update: Atualiza um post existente.
destroy: Deleta um post.

Passo 6: Definir as Rotas da API

Agora, vamos definir as rotas para nossa API de posts. Abra o arquivo src/App.php e adicione o seguinte código:

$app = new \Lithe\App;

$app->set('routes', __DIR__ . '/routes');

$app->listen();

O código acima cria uma instância do aplicativo Lithe. A linha $app->set('routes', __DIR__ . '/routes'); informa ao Lithe onde encontrar os arquivos de rotas. O Lithe vai carregar automaticamente todos os arquivos dentro da pasta src/routes. Cada arquivo de rota será mapeado para a URL com base no seu nome. Por exemplo:

O arquivo cart.php vai para a rota /cart.
O arquivo admin/dashboard.php vai para a rota /admin/dashboard.

A linha $app->listen(); faz com que o Lithe comece a "ouvir" as solicitações, ou seja, ele aguarda por requisições e as direciona para as rotas definidas.

Agora, crie um arquivo chamado posts.php dentro da pasta src/routes/posts para representar a rota /posts e adicione o seguinte código:

use App\Http\Controllers\PostController;
use function Lithe\Orbis\Http\Router\{get, post, put, delete};

get('/posts', [PostController::class, 'index']);
get('/posts/:id', [PostController::class, 'show']);
post('/posts', [PostController::class, 'store']);
put('/posts/:id', [PostController::class, 'update']);
delete('/posts/:id', [PostController::class, 'destroy']);

Essas rotas conectam os métodos do PostController às URLs da API.

Passo 7: Testar a API

Agora que tudo está configurado, você pode testar sua API com ferramentas como Postman ou Insomnia. Aqui estão os endpoints que você pode testar:

GET /posts: Retorna todos os posts.
GET /posts/:id: Retorna um post específico.
POST /posts: Cria um novo post.
PUT /posts/:id: Atualiza um post existente.
DELETE /posts/:id: Deleta um post.

Agora, você acabou de criar uma API de Mini Blog com o Lithe e o Eloquent ORM! O Lithe configurou automaticamente o Eloquent para você, e nós apenas fizemos algumas modificações nas variáveis de ambiente e criamos os modelos e controladores necessários. Agora você tem uma API RESTful completa para gerenciar posts de um blog.

Para mais informações e detalhes sobre como usar o Lithe e o Eloquent ORM, acesse a documentação oficial do Lithe aqui: Documentação do Lithe.

Blog