DEV Community

Lithe
Lithe

Posted on • Edited on

2 1 1 1 1

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
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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

php line make:migration create_posts_table
Enter fullscreen mode Exit fullscreen mode

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;
}
Enter fullscreen mode Exit fullscreen mode

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');
    }
};
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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']);
    }
}
Enter fullscreen mode Exit fullscreen mode

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();
Enter fullscreen mode Exit fullscreen mode

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 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']);
Enter fullscreen mode Exit fullscreen mode

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.

Image of Timescale

🚀 pgai Vectorizer: SQLAlchemy and LiteLLM Make Vector Search Simple

We built pgai Vectorizer to simplify embedding management for AI applications—without needing a separate database or complex infrastructure. Since launch, developers have created over 3,000 vectorizers on Timescale Cloud, with many more self-hosted.

Read more →

Top comments (0)

Sentry image

See why 4M developers consider Sentry, “not bad.”

Fixing code doesn’t have to be the worst part of your day. Learn how Sentry can help.

Learn more