Este guia passo a passo irá te ensinar a construir uma aplicação CRUD utilizando PHP, MySQL e o framework Lithe. Abordaremos desde a configuração do banco de dados até a implementação de controladores para gerenciar operações CRUD.

Configuração do Ambiente

Antes de iniciar, assegure-se de ter o Composer instalado em sua máquina. O Composer é uma ferramenta essencial para gerenciar dependências em projetos PHP. Caso não tenha o Composer, você pode baixá-lo e instalá-lo a partir do site oficial do Composer.

Criando um Novo Projeto Lithe

Para criar um novo projeto com o framework Lithe, abra o terminal e execute o seguinte comando:

composer create-project lithephp/lithephp crud-app

Isso criará um diretório chamado crud-app, onde todos os arquivos do projeto Lithe serão instalados. Após a instalação, navegue para o diretório do projeto:

cd crud-app

Configurando o Banco de Dados

Agora, você precisa configurar a conexão com o banco de dados. Localize o arquivo .env na raiz do projeto. Este arquivo armazena as variáveis de ambiente que o Lithe usará durante a execução.

No arquivo .env, defina suas variáveis de conexão ao banco de dados conforme o exemplo abaixo:

DB_CONNECTION_METHOD=mysqli
DB_CONNECTION=mysql
DB_HOST=localhost
DB_NAME=lithe
DB_USERNAME=root
DB_PASSWORD=
DB_SHOULD_INITIATE=true

Detalhes das Variáveis

DB_CONNECTION_METHOD: Método de conexão (neste caso, mysqli).
DB_CONNECTION: Tipo de banco de dados (por exemplo, mysql).
DB_HOST: Endereço do servidor de banco de dados (normalmente localhost para desenvolvimento local).
DB_NAME: Nome do banco de dados que será utilizado (por exemplo, lithe).
DB_USERNAME: Nome de usuário para acessar o banco de dados (padrão root para muitas configurações locais).
DB_PASSWORD: Senha do usuário do banco de dados (deixe em branco se não houver).
DB_SHOULD_INITIATE: Define se o banco de dados deve ser iniciado automaticamente ao iniciar a aplicação.

Após configurar o arquivo .env, você estará pronto para prosseguir com a criação da aplicação CRUD.

Com essas variáveis, o Lithe se conecta automaticamente ao banco de dados. Isso é feito pelo arquivo de configuração em src/database/config/database.php, que contém o seguinte método:

use Lithe\Database\Manager as DB;

return DB::initialize();

Esse método retorna a conexão do banco de dados.

Criando Migrações

Após configurar o banco de dados, o próximo passo é criar a estrutura do banco de dados. Para isso, utilizamos o comando make:migration do Lithe. Execute o seguinte comando para criar uma migração:

php line make:migration CreateUsersTable

Isso criará um arquivo de migração dentro do diretório src/database/migrations/, com um nome no formato YYYY_MM_DD_HHMMSS_CreateUsersTable.php.

A migração criada terá a seguinte estrutura:

return new class
{
    /**
     * Executa as migrações.
     *
     * @param mysqli $db
     * @return void
     */
    public function up(mysqli $db): void
    {
        $query = "
            CREATE TABLE IF NOT EXISTS users (
                id INT(11) AUTO_INCREMENT PRIMARY KEY,
                name VARCHAR(255) NOT NULL,
                email VARCHAR(255) UNIQUE NOT NULL,
                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
            )
        ";
        $db->query($query);
    }

    /**
     * Reverte as migrações.
     *
     * @param mysqli $db
     * @return void
     */
    public function down(mysqli $db): void
    {
        $query = "DROP TABLE IF EXISTS users";
        $db->query($query);
    }
};

Após definir a estrutura da migração, execute o comando a seguir para aplicar as migrações e criar a tabela no banco de dados:

php line migrate

Criando um Modelo

Para gerar um modelo que interaja com a tabela users, execute o seguinte comando:

php line make:model User

Isso criará um arquivo em src/models, que servirá como base para manipular os dados do usuário. O modelo gerado se parecerá com isso:

namespace App\Models;

use Lithe\Database\Manager as DB;

class User
{
    // Aqui vai a lógica do modelo
}

Métodos CRUD no Modelo

Adicione métodos estáticos para realizar operações CRUD usando mysqli.

Create (Criar)

Para inserir um novo usuário, adicione este método:

public static function create(array $data): bool
{
    $stmt = DB::connection()->prepare("INSERT INTO users (name, email) VALUES (?, ?)");
    $stmt->bind_param('ss', $data['name'], $data['email']);
    return $stmt->execute();
}

Read (Ler)

Para buscar usuários, implemente os métodos a seguir:

public static function all(): array
{
    return DB::connection()->query("SELECT * FROM users")->fetch_all(MYSQLI_ASSOC);
}

public static function find(int $id): ?array
{
    $stmt = DB::connection()->prepare("SELECT * FROM users WHERE id = ?");
    $stmt->bind_param('i', $id);
    $stmt->execute();
    return $stmt->get_result()->fetch_assoc() ?: null;
}

Update (Atualizar)

Para atualizar um usuário existente:

public static function update(int $id, array $data): bool
{
    $stmt = DB::connection()->prepare("UPDATE users SET name = ?, email = ? WHERE id = ?");
    $stmt->bind_param('ssi', $data['name'], $data['email'], $id);
    return $stmt->execute();
}

Delete (Excluir)

E para excluir um usuário:

public static function delete(int $id): bool
{
    $stmt = DB::connection()->prepare("DELETE FROM users WHERE id = ?");
    $stmt->bind_param('i', $id);
    return $stmt->execute();
}

Controladores Básicos

Para gerar rapidamente um novo controlador, execute o comando line make:controller. Todos os controladores gerados são armazenados no diretório src/http/controllers:

php line make:controller UserController

Um controlador pode ter qualquer número de métodos públicos que responderão às requisições HTTP. Veja um exemplo de implementação básica para a tabela users:

namespace App\Http\Controllers;

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

class UserController
{
    /**
     * Mostra o perfil de um usuário específico.
     */
    public function show(Request $req, Response $res)
    {
        $id = $req->param('id');

        return $res->view('user.profile', [
            'user' => User::find($id)
        ]);
    }

    /**
     * Cria um novo usuário.
     */
    public function store(Request $req, Response $res)
    {
        $data = (array) $req->body(); // Obtém todos os dados do pedido
        User::create($data);

        return $res->redirect('/users'); // Redireciona para a lista de usuários
    }

    /**
     * Atualiza um usuário existente.
     */
    public function update(Request $req, Response $res)
    {
        $id = $req->param('id');
        $data = (array) $req->body(); // Obtém todos os dados do pedido
        User::update($id, $data);

        return $res->redirect('/users'); // Redireciona para a lista de usuários
    }

    /**
     * Exclui um usuário.
     */
    public function delete(Request $req, Response $res)
    {
        $id = $req->param('id');
        User::delete($id);

        return $res->redirect('/users'); // Redireciona para a lista de usuários
    }
}

Adicionando Visualizações

Para exibir as informações dos usuários, crie arquivos de visualização no diretório src/views. Um exemplo de arquivo pode ser user/profile.php, onde você irá construir a interface de exibição dos dados do usuário.

Iniciando a Aplicação

Para começar a desenvolver com o Lithe, você precisa criar uma nova instância da classe Lithe\App no arquivo src/App.php e definir as rotas.

use App\Http\Controllers\UserController;

$app = new \Lithe\App;

$app->get('/users/:id', [UserController::class, 'show']);
$app->post('/users', [UserController::class, 'store']);
$app->put('/users/:id', [UserController::class, 'update']);
$app->delete('/users/:id', [UserController::class, 'delete']);

Rodando a Aplicação

Após definir as rotas, é fundamental chamar o método listen() para iniciar o servidor. Você pode fazer isso no mesmo arquivo src/App.php:

$app->listen();

E para rodar a aplicação, utilize o comando:

php line serve

Isso inicializa um servidor local que você pode acessar em http://localhost:8000.

Agora que sua aplicação CRUD está configurada e em execução, você poderá acessar as rotas de usuários diretamente no seu navegador. Para visualizar a lista de usuários ou interagir com as funções que você implementou, basta acessar:

http://localhost:8000/users

Essa rota permitirá que você visualize todos os usuários cadastrados e realize operações como criar, atualizar ou excluir registros conforme as funcionalidades que você implementou nos controladores.

Conclusão

Com esses passos, você já possui uma aplicação CRUD funcional usando PHP, MySQL e o framework Lithe. Agora, você pode expandir essa base para adicionar mais recursos e funcionalidades conforme sua necessidade.

Para mais informações sobre como utilizar o Lithe, consulte a documentação oficial do Lithe. A documentação abrange desde a configuração inicial até recursos avançados, ajudando você a aproveitar ao máximo o potencial do framework.

Divirta-se programando!

Criando uma Aplicação CRUD com PHP, MySQL e Lithe