DEV Community: Lithe

Introducing Lithe SwissHelper: Simplifying PHP Development

Lithe — Fri, 03 Jan 2025 13:53:33 +0000

Introducing SwissHelper

Meet Lithe SwissHelper, a lightweight yet powerful PHP utility library designed to simplify your development process. Whether it's string manipulations, array operations, data validations, or formatting tasks, SwissHelper has you covered. With a focus on developer experience and clean, readable code, SwissHelper is here to make common programming tasks easier.

Why Use SwissHelper?

Convenience: A comprehensive set of helper functions for everyday programming tasks.
Efficiency: Reduce code repetition and save development time.
Clarity: Write cleaner, more readable, and maintainable PHP code.

Installation

Getting started with SwissHelper is easy. Install it via Composer:

composer require lithephp/swisshelper

After installation, include the Composer autoloader in your project:

require 'vendor/autoload.php';

Key Features

1. Simplified String Manipulation

SwissHelper offers intuitive methods for processing strings. Here are a few examples:

Creating Slugs:

  $slug = str('Hello World!')->slug(); // Output: "hello-world"

Extracting Numbers:

  $numbers = str('Phone: (123) 456-7890')->onlyNumbers(); // Output: "1234567890"

Applying Masks:

  $masked = str('12345678901')->mask('###.###.###-##'); // Output: "123.456.789-01"

2. Powerful Array Handling

Access and manipulate arrays with ease:

Nested Access:

  $array = ['user' => ['name' => 'John Doe']];
  $name = arr($array)->get('user.name'); // Output: "John Doe"

Key Filtering:

  $filtered = arr(['a' => 1, 'b' => 2])->only(['a']); // Output: ['a' => 1]

3. Data Validation

SwissHelper simplifies data validation with a robust set of validators:

Email Validation:

  validate('user@example.com')->email(); // Output: true

Password Validation:

  validate('StrongP@ssw0rd')->password(); // Output: true

4. Date and Time Utilities

Get Current Date:

  $currentDate = now('Y-m-d'); // Output: Current date in 'YYYY-MM-DD' format

Manipulate Dates:

  $yesterday = now()->modify('-1 day'); // Output: DateTime object for yesterday

5. Money Formatting

Handle monetary values effortlessly with formatting for various currencies:

$formatted = money(1234.56, 'USD'); // Output: "$1,234.56"

6. Random String Generation

Generate random strings for various use cases:

$randomString = random(10); // Output: A 10-character alphanumeric string

7. URL Utilities

Get Current URL:

  $currentUrl = url()->current();

Generate URLs with Query Parameters:

  $urlWithQuery = url()->to('search')->with(['q' => 'SwissHelper']);

Testing and Contributions

SwissHelper comes with a robust test suite. Run the tests with:

composer test

Want to Contribute?

We'd love to have you on board! Fork the repository, create a branch for your feature, and submit a pull request. Follow PSR-12 coding standards to maintain consistency.

Join the SwissHelper Community

Try SwissHelper today and experience smoother PHP development. Share your ideas, report issues, and contribute on GitHub. Let's build something amazing together!

Find SwissHelper on Packagist: Lithe SwissHelper.

Introduzindo o Lithe SwissHelper: Simplificando o Desenvolvimento em PHP

Lithe — Fri, 03 Jan 2025 13:51:27 +0000

Apresentando o SwissHelper

Conheça o Lithe SwissHelper, uma biblioteca de utilitários PHP leve, mas poderosa, projetada para simplificar seu processo de desenvolvimento. Seja para manipulações de strings, operações com arrays, validações de dados ou tarefas de formatação, o SwissHelper cobre tudo. Com foco na experiência do desenvolvedor e em um código limpo e legível, o SwissHelper está aqui para tornar tarefas comuns de programação mais fáceis.

Por que usar o SwissHelper?

Conveniência: Um conjunto abrangente de funções auxiliares para tarefas do dia a dia de programação.
Eficiência: Reduza a repetição de código e economize tempo de desenvolvimento.
Clareza: Escreva códigos PHP mais limpos, legíveis e fáceis de manter.

Instalação

Começar a usar o SwissHelper é fácil. Instale-o via Composer:

composer require lithephp/swisshelper

Depois de instalado, inclua o autoloader do Composer no seu projeto:

require 'vendor/autoload.php';

Principais Recursos

1. Manipulação de Strings Simplificada

O SwissHelper oferece métodos intuitivos para processar strings. Aqui estão alguns exemplos:

Criação de Slugs:

  $slug = str('Hello World!')->slug(); // Saída: "hello-world"

Extração de Números:

  $numbers = str('Phone: (123) 456-7890')->onlyNumbers(); // Saída: "1234567890"

Aplicação de Máscaras:

  $masked = str('12345678901')->mask('###.###.###-##'); // Saída: "123.456.789-01"

2. Manipulação Poderosa de Arrays

Acesse e manipule arrays com facilidade:

Acesso Aninhado:

  $array = ['user' => ['name' => 'John Doe']];
  $name = arr($array)->get('user.name'); // Saída: "John Doe"

Filtragem de Chaves:

  $filtered = arr(['a' => 1, 'b' => 2])->only(['a']); // Saída: ['a' => 1]

3. Validação de Dados

O SwissHelper simplifica a validação de dados com um conjunto robusto de validadores:

Validação de E-mail:

  validate('user@example.com')->email(); // Saída: true

Validação de Senha:

  validate('StrongP@ssw0rd')->password(); // Saída: true

4. Utilitários de Data e Hora

Obter a Data Atual:

  $currentDate = now('Y-m-d'); // Saída: Data atual no formato 'YYYY-MM-DD'

Manipular Datas:

  $yesterday = now()->modify('-1 day'); // Saída: Objeto DateTime para ontem

5. Formatação Monetária

Lide com valores monetários de forma simples, com formatação para várias moedas:

$formatted = money(1234.56, 'USD'); // Saída: "$1,234.56"

6. Geração de Strings Aleatórias

Gere strings aleatórias para diversos casos de uso:

$randomString = random(10); // Saída: Uma string alfanumérica de 10 caracteres

7. Utilitários de URL

Obter URL Atual:

  $currentUrl = url()->current();

Gerar URLs com Parâmetros de Consulta:

  $urlWithQuery = url()->to('search')->with(['q' => 'SwissHelper']);

Testes e Contribuições

O SwissHelper vem com uma suíte de testes robusta. Execute os testes com:

composer test

Quer Contribuir?

Adoraríamos ter você a bordo! Faça um fork do repositório, crie um branch para sua funcionalidade e envie um pull request. Siga os padrões de codificação PSR-12 para manter a consistência.

Junte-se à Comunidade SwissHelper

Experimente o SwissHelper hoje e viva uma experiência de desenvolvimento PHP mais tranquila. Compartilhe suas ideias, reporte problemas e contribua no GitHub. Vamos construir algo incrível juntos!

Encontre o SwissHelper no Packagist: Lithe SwissHelper.

Lithe Framework: Incredible Projects Built with It!

Lithe — Sat, 21 Dec 2024 18:44:36 +0000

Hey, Devs! 👋

If you're looking for a lightweight, powerful, and easy-to-use PHP framework, check out Lithe! It's already being used to create amazing projects across various fields. Here are some examples:

🔹 Rialse.com

The official Rialse website was built with Lithe, ensuring a high-performance and scalable experience for clients in Angola and beyond.

🔹 Backend for an Online Bank

Lithe proved its strength by being chosen for the backend of a robust and secure banking platform, showing that it can handle critical and complex systems.

🔹 Financial Management System

It was used to develop the backend of a complete financial management system! This system tracks sales, expenses, profits, and more, helping businesses manage their finances efficiently and accurately.

Why is Lithe the right choice?

🚀 Performance: Fast and optimized for modern applications.
🔒 Security: Perfect even for sensitive systems like financial platforms.
📚 Documentation: Easy to learn and well-documented to speed up development.
🌐 Open Source: Completely free and available to everyone.

🔗 Ready to transform your projects? Start now with Lithe! Check out the official documentation and see how it can take your ideas to the next level.

Let us know in the comments what you think or share your experiences with Lithe. We’re excited to see what you’re building! 🚀

Framework Lithe: Projetos incríveis feitos com ele!

Lithe — Sat, 21 Dec 2024 18:43:50 +0000

Fala, Devs! 👋

Se você está procurando um framework PHP leve, poderoso e fácil de usar, conheça o Lithe! Ele já está sendo usado para criar projetos impressionantes em diferentes áreas. Confira alguns exemplos:

🔹 Rialse.com

O site oficial da Rialse foi construído com o Lithe, garantindo uma experiência de alta performance e escalabilidade para clientes em Angola e além.

🔹 Backend de um Banco Online

O Lithe mostrou sua força ao ser escolhido para o backend de uma plataforma bancária robusta e segura, provando que pode lidar com sistemas críticos e complexos.

🔹 Sistema de Gestão Financeira

Foi usado para desenvolver o backend de um sistema de gestão financeira completo! Ele registra vendas, despesas, lucros e outros dados, ajudando empresas a gerenciarem suas finanças com eficiência e precisão.

Por que o Lithe é a escolha certa?

🚀 Performance: Rápido e otimizado para aplicações modernas.
🔒 Segurança: Ideal até para sistemas sensíveis como plataformas financeiras.
📚 Documentação: Fácil de aprender e bem documentado para acelerar o desenvolvimento.
🌐 Open Source: Totalmente gratuito e disponível para todos.

🔗 Quer transformar seus projetos? Comece agora com o Lithe! Confira a documentação oficial e veja como ele pode levar suas ideias para o próximo nível.

Deixe nos comentários o que você achou ou compartilhe suas experiências com o Lithe. Estamos ansiosos para ver o que você está criando! 🚀

The First Project Built with Lithe Is Now Live!

Lithe — Thu, 05 Dec 2024 18:05:29 +0000

We are excited to announce that the first project created with Lithe is now live! Rialse.com, an online store specializing in high-quality products, is the first major project developed with our innovative and high-performance PHP framework.

Rialse.com - Online Store

Rialse.com is not just another online store. It has a special connection with Lithe, being created by none other than William Humbwavali, the creator of Lithe. The company uses the framework to build a fast, efficient, and scalable e-commerce platform.

Moreover, Rialse benefits from integrations like Eloquent and Blade, taking advantage of the simplicity and flexibility of Lithe, along with the robustness of the tools it provides. Lithe's routing, middleware, and controllers system ensures the application is easy to maintain and performs at a high level, all with clean and organized code.

Lithe allows Rialse to offer its customers a smooth and secure shopping experience, while the development team can work more efficiently, thanks to a framework that simplifies the implementation of new features.

Check out Rialse.com here and see how Lithe is helping to transform this e-commerce platform!

Ready to Build Your Next Project with Lithe?

If you also want to develop a project with agility, performance, and simplicity, Lithe is the right choice. The full documentation is available here. Don’t waste time and start turning your ideas into powerful solutions right now!

O Primeiro Projeto Criado com Lithe Já Está no Ar!

Lithe — Thu, 05 Dec 2024 18:04:23 +0000

É com grande entusiasmo que anunciamos que o primeiro projeto criado com o Lithe já está no ar! A Rialse.com, uma loja online especializada em produtos de alta qualidade, é o primeiro grande projeto a ser desenvolvido com o nosso framework PHP inovador e de alto desempenho.

Rialse.com - Loja Online

A Rialse.com não é apenas mais uma loja online. Ela tem um envolvimento especial com o Lithe, sendo criada por ninguém menos que o William Humbwavali, o criador do Lithe. A empresa utiliza o framework para construir uma plataforma de e-commerce rápida, eficiente e fácil de escalar.

Além disso, a Rialse se beneficia de integrações como Eloquent e Blade, aproveitando a simplicidade e a flexibilidade do Lithe, com a robustez das ferramentas que ele oferece. O sistema de rotas, middleware e controllers do Lithe garante que a aplicação seja de fácil manutenção e com alta performance, tudo com um código limpo e organizado.

O Lithe permite que a Rialse proporcione aos seus clientes uma experiência de compra ágil e segura, enquanto a equipe de desenvolvimento consegue trabalhar de forma mais eficiente, com um framework que facilita a implementação de novas funcionalidades.

Dê uma olhada no site da Rialse.com aqui e veja como o Lithe está ajudando a transformar essa plataforma de e-commerce!

Pronto para Criar Seu Próximo Projeto com o Lithe?

Se você também quer desenvolver um projeto com agilidade, performance e simplicidade, o Lithe é a escolha certa. A documentação completa está disponível aqui. Não perca tempo e comece agora mesmo a transformar suas ideias em soluções poderosas!

Lithe Events: A Lightweight and Powerful Event Handling Library for PHP

Lithe — Mon, 02 Dec 2024 20:38:25 +0000

Lithe Events is a lightweight yet powerful library for event management in PHP applications. It allows you to easily create, register, emit, and remove events, creating a decoupled and flexible architecture. This detailed guide will walk you through how to use the library from installation to full implementation.

Installation
Usage
- Using the EventDispatcher Class
- Creating an Event
- Registering Listeners
- Emitting Events
- Removing Listeners
Using Lithe Orbis
Full Example

Installation

To install lithemod/events in your PHP project, you will need to use Composer. Run the following command in your project directory:

composer require lithemod/events

This command will download the package and update your project's composer.json file automatically, allowing you to start using the library.

Usage

Using the EventDispatcher Class

The EventDispatcher class is the central piece for managing events and listeners. It allows you to register listeners, emit events, and remove listeners. Let’s go through how to use it step by step.

Creating an Event

To create an event, you instantiate the Event class, which stores the event name and any additional data you want to associate with it. Here's an example:

use Lithe\Events\Event;

$event = new Event('event.name', ['key' => 'value']);

event.name: The name of the event, which is a string that identifies the event.
['key' => 'value']: An optional associative array containing any additional data you want to pass with the event.

Registering Listeners

Now that you have the event, it’s time to register a listener that will be triggered when the event is emitted. To do this, use the on method of the EventDispatcher class.

use Lithe\Events\EventDispatcher;

$dispatcher = new EventDispatcher();

$listener = function ($data) {
    echo "Event data: " . json_encode($data);
};

// Register the listener
$dispatcher->on('event.name', $listener);

Here, the listener is an anonymous function that will be called whenever the 'event.name' event is emitted. The listener receives the data passed by the event.

Emitting Events

To emit an event and trigger all registered listeners, use the emit method of the EventDispatcher class.

$event = new Event('event.name', ['key' => 'value']);
$dispatcher->emit($event);

When the event is emitted, all listeners registered for 'event.name' are called and receive the event data.

Removing Listeners

If you no longer need a listener for a specific event, you can remove it using the off method.

$dispatcher->off('event.name', $listener);

This code removes the listener from the list of listeners for the 'event.name' event.

Using Lithe Orbis

Lithe Orbis is a powerful class that acts as a global instance manager, allowing you to abstract complex functionalities into simple, reusable components. This makes event management even easier and more direct.

With Lithe Orbis, you can use event management functions more simply. Here’s how you can register listeners, emit events, and remove them using the Orbis class:

Registering Listeners with Lithe Orbis

To register a listener using Lithe Orbis, you can directly use the on function:

use Lithe\Orbis\Events;

$listener = function ($data) {
    echo "Event data: " . json_encode($data);
};

// Register the listener
Events\on('event.name', $listener);

Emitting Events with Lithe Orbis

To emit an event using Lithe Orbis, use the emit function:

use Lithe\Orbis\Events;
use Lithe\Events\Event;

$event = new Event('event.name', ['key' => 'value']);
Events\emit($event);

Removing Listeners with Lithe Orbis

Removing listeners with Lithe Orbis is as simple as using the off function:

Events\off('event.name', $listener);

For more information and detailed documentation on Lithe Orbis, you can check the Orbis documentation.

Full Example

Now, let’s look at a full example using the functions and classes mentioned. This example shows how to register listeners, emit events, and remove them.

use Lithe\Events\Event;
use Lithe\Orbis\Events;

// Creating a listener
$listener = function ($data) {
    echo "Event received with data: " . json_encode($data) . "\n";
};

// Registering the listener
Events\on('my.event', $listener);

// Emitting the event
$data = ['msg' => 'Hello, world!'];
Events\emit(new Event('my.event', $data));

// Removing the listener
Events\off('my.event', $listener);

Explanation of the Example:

Creating a listener: This listener will display the event data every time it’s triggered.
Registering the listener for the 'my.event' event.
Emitting the event with associated data.
Removing the listener after it’s used.

Lithe Events is a simple yet powerful library that allows you to efficiently manage events in your PHP applications. Whether you're registering listeners, emitting events, or removing them, the library provides all the tools you need to create a modular and decoupled architecture.

Try Lithe Events in your next project and see how it can improve the flexibility and maintainability of your code!

Manipulando Eventos com Simplicidade em PHP com Lithe Events

Lithe — Mon, 02 Dec 2024 20:36:46 +0000

O Lithe Events é uma biblioteca leve e poderosa para manipulação de eventos em aplicações PHP. Com ela, você pode facilmente criar, registrar, emitir e remover eventos, criando uma arquitetura desacoplada e flexível. Este guia detalhado irá te ensinar como usar a biblioteca desde a instalação até a implementação completa.

Índice

Instalação
Uso
- Usando a Classe EventDispatcher
- Criando um Evento
- Registrando Listeners
- Emitindo Eventos
- Removendo Listeners
Usando o Lithe Orbis
Exemplo Completo

Instalação

Para instalar o lithemod/events em seu projeto PHP, você precisará usar o Composer. Execute o seguinte comando no diretório do seu projeto:

composer require lithemod/events

Este comando vai baixar o pacote e atualizar o arquivo composer.json do seu projeto automaticamente, permitindo que você comece a usar a biblioteca.

Uso

Usando a Classe EventDispatcher

A classe EventDispatcher é a peça central para gerenciar eventos e ouvintes. Ela permite que você registre ouvintes, emita eventos e remova ouvintes. Vamos entender como usá-la passo a passo.

Criando um Evento

Para criar um evento, você precisa instanciar a classe Event, que armazena o nome do evento e quaisquer dados adicionais que você deseja associar a ele. Veja um exemplo:

use Lithe\Events\Event;

$event = new Event('event.name', ['key' => 'value']);

event.name: O nome do evento, que é uma string que identifica o evento.
['key' => 'value']: Um array associativo opcional que contém os dados adicionais que você deseja passar com o evento.

Registrando Listeners

Agora que você tem o evento, é hora de registrar um ouvinte (listener) que será acionado quando o evento for emitido. Para isso, você usa o método on da classe EventDispatcher.

use Lithe\Events\EventDispatcher;

$dispatcher = new EventDispatcher();

$listener = function ($data) {
    echo "Dados do evento: " . json_encode($data);
};

// Registrar o ouvinte
$dispatcher->on('event.name', $listener);

Aqui, o ouvinte é uma função anônima que será chamada sempre que o evento 'event.name' for emitido. O ouvinte recebe os dados passados pelo evento.

Emitindo Eventos

Para emitir um evento e disparar todos os ouvintes registrados, usamos o método emit da classe EventDispatcher.

$event = new Event('event.name', ['key' => 'value']);
$dispatcher->emit($event);

Quando o evento é emitido, todos os ouvintes registrados para 'event.name' são chamados e recebem os dados do evento.

Removendo Listeners

Se você não precisar mais de um ouvinte para um evento específico, pode removê-lo usando o método off.

$dispatcher->off('event.name', $listener);

Esse código remove o ouvinte da fila de ouvintes para o evento 'event.name'.

Usando Orbis

Lithe Orbis é uma classe poderosa que atua como um gerenciador de instâncias global, permitindo que você abstraia funcionalidades complexas em componentes simples e reutilizáveis. Isso ajuda a tornar o gerenciamento de eventos ainda mais fácil e direto.

Com o Lithe Orbis, você pode usar funções de gerenciamento de eventos de forma mais simples. Aqui está como você pode registrar ouvintes, emitir eventos e removê-los usando as funções da classe Orbis:

Registrando Listeners com Lithe Orbis

Para registrar um ouvinte usando o Lithe Orbis, você pode usar a função on diretamente:

use Lithe\Orbis\Events;

$listener = function ($data) {
    echo "Dados do evento: " . json_encode($data);
};

// Registrar o ouvinte
Events\on('event.name', $listener);

Emitindo Eventos com Lithe Orbis

Para emitir um evento usando o Lithe Orbis, use a função emit:

use Lithe\Orbis\Events;
use Lithe\Events\Event;

$event = new Event('event.name', ['key' => 'value']);
Events\emit($event);

Removendo Listeners com Lithe Orbis

Remover ouvintes usando o Lithe Orbis é tão simples quanto usar a função off:

Events\off('event.name', $listener);

Para mais informações e documentação detalhada sobre o Lithe Orbis, você pode acessar o link da documentação do Orbis.

Exemplo Completo

Agora, vamos ver um exemplo completo utilizando as funções e classes mencionadas. Este exemplo mostra como registrar ouvintes, emitir eventos e removê-los.

use Lithe\Events\Event;
use Lithe\Orbis\Events;

// Criando um ouvinte
$listener = function ($data) {
    echo "Evento recebido com dados: " . json_encode($data) . "\n";
};

// Registrando o ouvinte
Events\on('my.event', $listener);

// Emitindo o evento
$data = ['msg' => 'Olá, mundo!'];
Events\emit(new Event('my.event', $data));

// Removendo o ouvinte
Events\off('my.event', $listener);

Explicação do Exemplo:

Criamos um ouvinte: Esse ouvinte irá exibir os dados do evento sempre que ele for disparado.
Registramos o ouvinte para o evento 'my.event'.
Emitimos o evento com dados associados.
Removemos o ouvinte depois de usá-lo.

O Lithe Events é uma biblioteca simples, porém poderosa, que permite gerenciar eventos de forma eficiente em suas aplicações PHP. Seja para registrar ouvintes, emitir eventos ou removê-los, a biblioteca fornece todas as ferramentas necessárias para criar uma arquitetura modular e desacoplada.

Experimente o Lithe Events em seu próximo projeto e veja como ele pode melhorar a flexibilidade e manutenção do seu código!

Creating a Mini Blog API with Lithe and Eloquent

Lithe — Thu, 28 Nov 2024 20:07:24 +0000

Step 1: Install Lithe

The first step is to install Lithe in your project. If you haven’t done that yet, simply run the following command in the terminal:

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

This command creates a new project using Lithe. Lithe automatically configures Eloquent for you, but we need to adjust some settings in the .env file to connect to the database.

Step 2: Configure the Database

Now, let’s configure the database. Open the .env file at the root of your project and edit the database settings. To use Eloquent ORM with MySQL, the settings should look like this:

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

Since Lithe automatically configures Eloquent, the next step is to ensure Eloquent ORM is installed. If you haven’t done so, run the following command to install Eloquent ORM:

composer require illuminate/database

After installation, Lithe will be ready to use Eloquent ORM and interact with the database. With that, the database is now correctly configured for our Mini Blog API!

Step 3: Create the Model and Migration for Posts

Now, let’s create the model and migration to define the posts table in our database.

First, create the Post model with the following command:

php line make:model Post

Next, create the migration for the posts table:

php line make:migration create_posts_table

The model and migration are now created. Let’s configure them.

Post Model

The Post model is located in src/models/Post.php. Edit the file like this:

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Post extends Model
{
    // The table associated with the model
    protected $table = 'posts';

    // Fields that can be filled via mass-assignment
    protected $fillable = ['title', 'content'];

    // Use timestamps for created_at and updated_at
    public $timestamps = true;
}

In this code, we define the title and content fields as fillable, meaning they can be automatically populated when creating or updating a post.

Posts Table Migration

The generated migration will be located in src/database/migrations/{timestamp}_create_posts_table.php. Edit the migration to create the structure of the posts table:

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(); // Creates the auto-incrementing id field
            $table->string('title'); // Creates the title field
            $table->text('content'); // Creates the content field
            $table->timestamps(); // Creates created_at and updated_at fields
        });
    }

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

Here, we are creating the posts table with the fields id, title, content, and the date-time fields created_at and updated_at.

Step 4: Run the Migration

With the migration and model ready, let's run the migration to create the posts table in the database. Execute the following command:

php line migrate

This command will create the posts table in the database with the fields we defined in the migration.

Step 5: Create the Post Controller

Now, let's create a controller to manage the posts of the API. The controller will be responsible for handling HTTP requests and returning the data in an organized way.

To create the controller, execute:

php line make:controller PostController

This will generate a file in src/http/Controllers/PostController.php. Edit this file to include the CRUD (create, read, update, and delete) methods for the posts.

Here’s an example of how the PostController might look:

namespace App\Http\Controllers;

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

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

    // Show a specific post
    public function show(Request $req, Response $res)
    {
        $id = $req->param('id');

        $post = Post::find($id); // Find post by ID
        return $res->json($post);
    }

    // Create a new post
    public function store(Request $req, Response $res)
    {
        $data = (array) $req->body(); // Get data from request

        $post = Post::create($data); // Create a new post
        return $res->status(201)->json($post); // Return the created post with status 201
    }

    // Update an existing post
    public function update(Request $req, Response $res)
    {
        $id = $req->param('id');

        $data = (array) $req->body(); // Request data
        $post = Post::find($id); // Find post by ID

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

        return $res->status(404)->json(['message' => 'Post not found']);
    }

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

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

        return $res->status(404)->json(['message' => 'Post not found']);
    }
}

Here, we have five basic methods:

index: Lists all posts.
show: Displays a specific post.
store: Creates a new post.
update: Updates an existing post.
destroy: Deletes a post.

Step 6: Define the API Routes

Now, let's define the routes for our post API. Open the file src/App.php and add the following code:

$app = new \Lithe\App;

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

$app->listen();

The code above creates an instance of the Lithe app. The line $app->set('routes', __DIR__ . '/routes'); tells Lithe where to find the route files. Lithe will automatically load all files inside the src/routes folder. Each route file will be mapped to the URL based on its name. For example:

The file cart.php will go to the /cart route.
The file admin/dashboard.php will go to the /admin/dashboard route.

The line $app->listen(); makes Lithe "listen" for requests, i.e., it waits for incoming requests and directs them to the defined routes.

Now, create a file called posts.php inside the src/routes folder to represent the /posts route and add the following code:

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']);

These routes connect the methods in PostController to the API URLs.

Step 7: Test the API

Now that everything is set up, you can test your API with tools like Postman or Insomnia. Here are the endpoints you can test:

GET /posts: Returns all posts.
GET /posts/:id: Returns a specific post.
POST /posts: Creates a new post.
PUT /posts/:id: Updates an existing post.
DELETE /posts/:id: Deletes a post.

Now, you've just created a Mini Blog API with Lithe and Eloquent ORM! Lithe automatically set up Eloquent for you, and we just made a few adjustments to the environment variables and created the necessary models and controllers. Now you have a complete RESTful API to manage blog posts.

For more information and details on how to use Lithe and Eloquent ORM, visit the official Lithe documentation here: Lithe Documentation.

Criando uma API de Mini Blog com Lithe e Eloquent

Lithe — Thu, 28 Nov 2024 20:04:11 +0000

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

Creating a TodoList with PHP and the Lithe Framework: A Complete Guide

Lithe — Sat, 16 Nov 2024 20:52:57 +0000

In this tutorial, we will create a functional TodoList application using Lithe. You will learn how to structure your project, create interactive views, and implement a RESTful API to manage your tasks. This project will serve as an excellent example of how to build modern web applications with PHP.

Prerequisites

Composer installed
MySQL
Basic knowledge of PHP and JavaScript

Project Structure

First, let's create a new Lithe project:

composer create-project lithephp/lithephp todo-app
cd todo-app

Setting Up the Database

Edit the .env file in the root of the project with the following configuration:

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

Creating the Migration

Run the command to create a new migration:

php line make:migration CreateTodosTable

Edit the generated migration file in src/database/migrations/:

return new class
{
    public function up(mysqli $db): void
    {
        $query = "
            CREATE TABLE IF NOT EXISTS todos (
                id INT(11) AUTO_INCREMENT PRIMARY KEY,
                title VARCHAR(255) NOT NULL,
                completed BOOLEAN DEFAULT FALSE,
                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
            )
        ";
        $db->query($query);
    }

    public function down(mysqli $db): void
    {
        $query = "DROP TABLE IF EXISTS todos";
        $db->query($query);
    }
};

Run the migration:

php line migrate

Implementing the Model

Generate a new model:

php line make:model Todo

Edit the file src/models/Todo.php:

namespace App\Models;

use Lithe\Database\Manager as DB;

class Todo
{
    public static function all(): array
    {
        return DB::connection()
            ->query("SELECT * FROM todos ORDER BY created_at DESC")
            ->fetch_all(MYSQLI_ASSOC);
    }

    public static function create(array $data): ?array
    {
        $stmt = DB::connection()->prepare(
            "INSERT INTO todos (title, completed) VALUES (?, ?)"
        );
        $completed = false;
        $stmt->bind_param('si', $data['title'], $completed);
        $success = $stmt->execute();

        if ($success) {
            $id = $stmt->insert_id;
            return [
                'id' => $id,
                'title' => $data['title'],
                'completed' => $completed
            ];
        }

        return null;
    }

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

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

Creating the Controller

Generate a new controller:

php line make:controller TodoController

Edit the file src/http/controllers/TodoController.php:

namespace App\Http\Controllers;

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

class TodoController
{
    public static function index(Request $req, Response $res)
    {
        return $res->view('todo.index');
    }

    public static function list(Request $req, Response $res)
    {
        $todos = Todo::all();
        return $res->json($todos);
    }

    public static function store(Request $req, Response $res)
    {
        $data = (array) $req->body();
        $todo = Todo::create($data);
        $success = $todo ? true : false;

        return $res->json([
            'success' => $success,
            'message' => $success ? 'Task created successfully' : 'Failed to create task',
            'todo' => $todo
        ]);
    }

    public static function update(Request $req, Response $res)
    {
        $id = $req->param('id');
        $data = (array) $req->body();
        $success = Todo::update($id, $data);

        return $res->json([
            'success' => $success,
            'message' => $success ? 'Task updated successfully' : 'Failed to update task'
        ]);
    }

    public static function delete(Request $req, Response $res)
    {
        $id = $req->param('id');
        $success = Todo::delete($id);

        return $res->json([
            'success' => $success,
            'message' => $success ? 'Task removed successfully' : 'Failed to remove task'
        ]);
    }
}

Creating the Views

Create the src/views/todo directory and add the index.php file:

<!DOCTYPE html>
<html>
<head>
    <title>TodoList with Lithe</title>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <style>
        * {
            margin: 0;
            padding: 0;
            box-sizing: border-box;
            font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
        }

        body {
            min-height: 100vh;
            background-color: #ffffff;
            padding: 20px;
        }

        .container {
            max-width: 680px;
            margin: 0 auto;
            padding: 40px 20px;
        }

        h1 {
            color: #1d1d1f;
            font-size: 34px;
            font-weight: 700;
            margin-bottom: 30px;
        }

        .todo-form {
            display: flex;
            gap: 12px;
            margin-bottom: 30px;
            border-bottom: 1px solid #e5e5e7;
            padding-bottom: 30px;
        }

        .todo-input {
            flex: 1;
            padding: 12px 16px;
            font-size: 17px;
            border: 1px solid #e5e5e7;
            border-radius: 10px;
            background-color: #f5f5f7;
            transition: all 0.2s;
        }

        .todo-input:focus {
            outline: none;
            background-color: #ffffff;
            border-color: #0071e3;
        }

        .add-button {
            padding: 12px 20px;
            background: #0071e3;
            color: white;
            border: none;
            border-radius: 10px;
            font-size: 15px;
            font-weight: 500;
            cursor: pointer;
            transition: all 0.2s;
        }

        .add-button:hover {
            background: #0077ED;
        }

        .todo-list {
            list-style: none;
        }

        .todo-item {
            display: flex;
            align-items: center;
            padding: 16px;
            border-radius: 10px;
            margin-bottom: 8px;
            transition: background-color 0.2s;
        }

        .todo-item:hover {
            background-color: #f5f5f7;
        }

        .todo-checkbox {
            width: 22px;
            height: 22px;
            margin-right: 15px;
            cursor: pointer;
        }

        .todo-text {
            flex: 1;
            font-size: 17px;
            color: #1d1d1f;
        }

        .completed {
            color: #86868b;
            text-decoration: line-through;
        }

        .delete-button {
            padding: 8px 12px;
            background: none;
            color: #86868b;
            border: none;
            border-radius: 6px;
            font-size: 15px;
            cursor: pointer;
            opacity: 0;
            transition: all 0.2s;
        }

        .todo-item:hover .delete-button {
            opacity: 1;
        }

        .delete-button:hover {
            background: #f5f5f7;
            color: #ff3b30;
        }

        .loading {
            text-align: center;
            padding: 20px;
            color: #86868b;
        }

        .error {
            color: #ff3b30;
            text-align: center;
            padding: 20px;
        }
    </style>
</head>
<body>
    <div class="container">
        <h1>My Tasks</h1>
        <form class="todo-form" id="todoForm">
            <input type="text" class="todo-input" placeholder="Add new task" id="todoInput" required>
            <button type="submit" class="add-button">Add</button>
        </form>
        <div id="loading" class="loading">Loading tasks...</div>
        <ul class="todo-list" id="todoList"></ul>
    </div>

    <

script>
        const todoInput = document.getElementById('todoInput');
        const todoForm = document.getElementById('todoForm');
        const todoList = document.getElementById('todoList');
        const loading = document.getElementById('loading');

        async function fetchTodos() {
            const response = await fetch('/todos');
            const todos = await response.json();
            loading.style.display = 'none';
            renderTodos(todos);
        }

        function renderTodos(todos) {
            todoList.innerHTML = '';
            todos.forEach(todo => {
                const todoItem = document.createElement('li');
                todoItem.className = 'todo-item';
                todoItem.dataset.id = todo.id;

                const checkbox = document.createElement('input');
                checkbox.type = 'checkbox';
                checkbox.className = 'todo-checkbox';
                checkbox.checked = todo.completed;
                checkbox.addEventListener('change', () => updateTodo(todo.id, checkbox.checked));

                const text = document.createElement('span');
                text.className = 'todo-text';
                text.textContent = todo.title;
                if (todo.completed) {
                    text.classList.add('completed');
                }

                const deleteButton = document.createElement('button');
                deleteButton.className = 'delete-button';
                deleteButton.textContent = 'Delete';
                deleteButton.addEventListener('click', () => deleteTodo(todo.id));

                todoItem.appendChild(checkbox);
                todoItem.appendChild(text);
                todoItem.appendChild(deleteButton);
                todoList.appendChild(todoItem);
            });
        }

        async function addTodo() {
            const title = todoInput.value;
            if (!title) return;

            const response = await fetch('/todos', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                },
                body: JSON.stringify({ title })
            });

            const todo = await response.json();
            if (todo.success) {
                fetchTodos();
                todoInput.value = '';
            }
        }

        async function updateTodo(id, completed) {
            const response = await fetch(`/todos/${id}`, {
                method: 'PUT',
                headers: {
                    'Content-Type': 'application/json',
                },
                body: JSON.stringify({ completed })
            });

            if (response.ok) {
                fetchTodos();
            }
        }

        async function deleteTodo(id) {
            const response = await fetch(`/todos/${id}`, { method: 'DELETE' });
            if (response.ok) {
                fetchTodos();
            }
        }

        todoForm.addEventListener('submit', (e) => {
            e.preventDefault();
            addTodo();
        });

        fetchTodos();
    </script>
</body>
</html>

Aqui está a tradução para o inglês:

Setting Up the Routes

Update the src/App.php file to include the TodoList routes:

use App\Http\Controllers\TodoController;

$app = new \Lithe\App;

// Route for the main page
$app->get('/', [TodoController::class, 'index']);

// API routes
$app->get('/todos/list', [TodoController::class, 'list']);
$app->post('/todos', [TodoController::class, 'store']);
$app->put('/todos/:id', [TodoController::class, 'update']);
$app->delete('/todos/:id', [TodoController::class, 'delete']);

$app->listen();

Running the Application

To start the development server, run:

php line serve

Access http://localhost:8000 in your browser to see the application in action.

Implemented Features

Our TodoList has the following features:

Listing tasks in reverse chronological order
Adding new tasks
Marking tasks as completed/pending
Removing tasks
Responsive and user-friendly interface
Visual feedback for all actions
Error handling

Conclusion

You now have a fully functional TodoList application built with Lithe. This example demonstrates how to create a modern web application with PHP, including:

Proper MVC code structure
RESTful API implementation
Interactive user interface
Database integration
Error handling
User feedback

From here, you can expand the application by adding new features such as:

User authentication
Task categorization
Due dates
Filters and search

To keep learning about Lithe, visit the Linktree, where you can access the Discord, documentation, and much more!

Criando uma TodoList com PHP e o Framework Lithe: Um Guia Completo

Lithe — Sat, 16 Nov 2024 20:48:27 +0000

Neste tutorial, vamos criar uma aplicação TodoList funcional usando o Lithe. Você aprenderá a estruturar seu projeto, criar views interativas, e implementar uma API RESTful para gerenciar suas tarefas. Este projeto servirá como um excelente exemplo de como construir aplicações web modernas com PHP.

Pré-requisitos

Composer instalado
MySQL
Conhecimentos básicos de PHP e JavaScript

Estrutura do Projeto

Primeiro, vamos criar um novo projeto Lithe:

composer create-project lithephp/lithephp todo-app
cd todo-app

Configurando o Banco de Dados

Edite o arquivo .env na raiz do projeto com as seguintes configurações:

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

Criando a Migração

Execute o comando para criar uma nova migração:

php line make:migration CreateTodosTable

Edite o arquivo de migração gerado em src/database/migrations/:

return new class
{
    public function up(mysqli $db): void
    {
        $query = "
            CREATE TABLE IF NOT EXISTS todos (
                id INT(11) AUTO_INCREMENT PRIMARY KEY,
                title VARCHAR(255) NOT NULL,
                completed BOOLEAN DEFAULT FALSE,
                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
            )
        ";
        $db->query($query);
    }

    public function down(mysqli $db): void
    {
        $query = "DROP TABLE IF EXISTS todos";
        $db->query($query);
    }
};

Execute a migração:

php line migrate

Implementando o Modelo

Gere um novo modelo:

php line make:model Todo

Edite o arquivo src/models/Todo.php:

namespace App\Models;

use Lithe\Database\Manager as DB;

class Todo
{
    public static function all(): array
    {
        return DB::connection()
            ->query("SELECT * FROM todos ORDER BY created_at DESC")
            ->fetch_all(MYSQLI_ASSOC);
    }

    public static function create(array $data): ?array
    {
        $stmt = DB::connection()->prepare(
            "INSERT INTO todos (title, completed) VALUES (?, ?)"
        );
        $completed = false;
        $stmt->bind_param('si', $data['title'], $completed);
        $success = $stmt->execute();

        if ($success) {
            $id = $stmt->insert_id;
            return [
                'id' => $id,
                'title' => $data['title'],
                'completed' => $completed
            ];
        }

        return null;
    }

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

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

Criando o Controlador

Gere um novo controlador:

php line make:controller TodoController

Edite o arquivo src/http/controllers/TodoController.php:

namespace App\Http\Controllers;

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

class TodoController
{
    public static function index(Request $req, Response $res)
    {
        return $res->view('todo.index');
    }

    public static function list(Request $req, Response $res)
    {
        $todos = Todo::all();
        return $res->json($todos);
    }

    public static function store(Request $req, Response $res)
    {
        $data = (array) $req->body();
        $todo = Todo::create($data);
        $success = $todo ? true : false;

        return $res->json([
            'success' => $success,
            'message' => $success ? 'Tarefa criada com sucesso' : 'Falha ao criar tarefa',
            'todo' => $todo
        ]);
    }

    public static function update(Request $req, Response $res)
    {
        $id = $req->param('id');
        $data = (array) $req->body();
        $success = Todo::update($id, $data);

        return $res->json([
            'success' => $success,
            'message' => $success ? 'Tarefa atualizada com sucesso' : 'Falha ao atualizar tarefa'
        ]);
    }

    public static function delete(Request $req, Response $res)
    {
        $id = $req->param('id');
        $success = Todo::delete($id);

        return $res->json([
            'success' => $success,
            'message' => $success ? 'Tarefa removida com sucesso' : 'Falha ao remover tarefa'
        ]);
    }
}

Criando as Views

Crie o diretório src/views/todo e adicione o arquivo index.php:

<!DOCTYPE html>
<html>
<head>
    <title>TodoList com Lithe</title>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <style>
        * {
            margin: 0;
            padding: 0;
            box-sizing: border-box;
            font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
        }

        body {
            min-height: 100vh;
            background-color: #ffffff;
            padding: 20px;
        }

        .container {
            max-width: 680px;
            margin: 0 auto;
            padding: 40px 20px;
        }

        h1 {
            color: #1d1d1f;
            font-size: 34px;
            font-weight: 700;
            margin-bottom: 30px;
        }

        .todo-form {
            display: flex;
            gap: 12px;
            margin-bottom: 30px;
            border-bottom: 1px solid #e5e5e7;
            padding-bottom: 30px;
        }

        .todo-input {
            flex: 1;
            padding: 12px 16px;
            font-size: 17px;
            border: 1px solid #e5e5e7;
            border-radius: 10px;
            background-color: #f5f5f7;
            transition: all 0.2s;
        }

        .todo-input:focus {
            outline: none;
            background-color: #ffffff;
            border-color: #0071e3;
        }

        .add-button {
            padding: 12px 20px;
            background: #0071e3;
            color: white;
            border: none;
            border-radius: 10px;
            font-size: 15px;
            font-weight: 500;
            cursor: pointer;
            transition: all 0.2s;
        }

        .add-button:hover {
            background: #0077ED;
        }

        .todo-list {
            list-style: none;
        }

        .todo-item {
            display: flex;
            align-items: center;
            padding: 16px;
            border-radius: 10px;
            margin-bottom: 8px;
            transition: background-color 0.2s;
        }

        .todo-item:hover {
            background-color: #f5f5f7;
        }

        .todo-checkbox {
            width: 22px;
            height: 22px;
            margin-right: 15px;
            cursor: pointer;
        }

        .todo-text {
            flex: 1;
            font-size: 17px;
            color: #1d1d1f;
        }

        .completed {
            color: #86868b;
            text-decoration: line-through;
        }

        .delete-button {
            padding: 8px 12px;
            background: none;
            color: #86868b;
            border: none;
            border-radius: 6px;
            font-size: 15px;
            cursor: pointer;
            opacity: 0;
            transition: all 0.2s;
        }

        .todo-item:hover .delete-button {
            opacity: 1;
        }

        .delete-button:hover {
            background: #f5f5f7;
            color: #ff3b30;
        }

        .loading {
            text-align: center;
            padding: 20px;
            color: #86868b;
        }

        .error {
            color: #ff3b30;
            text-align: center;
            padding: 20px;
        }
    </style>
</head>
<body>
    <div class="container">
        <h1>Minhas Tarefas</h1>
        <form class="todo-form" id="todoForm">
            <input type="text" class="todo-input" placeholder="Adicionar nova tarefa" id="todoInput" required>
            <button type="submit" class="add-button">Adicionar</button>
        </form>
        <div id="loading" class="loading">Carregando tarefas...</div>
        <ul class="todo-list" id="todoList"></ul>
    </div>

    <script>
        const todoList = document.getElementById('todoList');
        const todoForm = document.getElementById('todoForm');
        const todoInput = document.getElementById('todoInput');
        const loading = document.getElementById('loading');

        // Carregar todas as tarefas
        async function loadTodos() {
            try {
                const response = await fetch('/todos/list');
                const todos = await response.json();
                loading.style.display = 'none';
                todoList.innerHTML = ''; // Limpar a lista antes de adicionar
                todos.forEach(todo => addTodoToDOM(todo));
            } catch (error) {
                loading.textContent = 'Não foi possível carregar as tarefas.';
                loading.classList.add('error');
            }
        }

        // Adicionar tarefa ao DOM
        function addTodoToDOM(todo) {
            console.log(todo)
            const li = document.createElement('li');
            li.className = 'todo-item';
            li.dataset.id = todo.id; // Associando o ID à tarefa
            li.innerHTML = `
        <input type="checkbox" class="todo-checkbox" ${todo.completed ? 'checked' : ''}>
        <span class="todo-text ${todo.completed ? 'completed' : ''}">${todo.title}</span>
        <button type="button" class="delete-button">Remover</button>
    `;

            const checkbox = li.querySelector('.todo-checkbox');
            checkbox.addEventListener('change', () => toggleTodo(todo.id, checkbox));

            const deleteButton = li.querySelector('.delete-button');
            deleteButton.addEventListener('click', () => deleteTodo(todo.id, li));

            todoList.appendChild(li);
        }

        // Criar nova tarefa
        todoForm.addEventListener('submit', async (e) => {
            e.preventDefault();
            const title = todoInput.value.trim();
            if (!title) return;

            try {
                const response = await fetch('/todos', {
                    method: 'POST',
                    headers: {
                        'Content-Type': 'application/json',
                    },
                    body: JSON.stringify({
                        title
                    })
                });

                const result = await response.json();

                if (result.success) {
                    const todo = {
                        id: result.todo.id,
                        title,
                        completed: false
                    };
                    addTodoToDOM(todo);
                    todoInput.value = '';
                } else {
                    alert(result.message);
                }
            } catch (error) {
                alert('Não foi possível adicionar a tarefa');
            }
        });

        // Atualizar status da tarefa
        async function toggleTodo(id, checkbox) {
            try {
                console.log(`Atualizando tarefa com ID: ${id}`);
                const response = await fetch(`/todos/${id}`, {
                    method: 'PUT',
                    headers: {
                        'Content-Type': 'application/json',
                    },
                    body: JSON.stringify({
                        completed: checkbox.checked ? 1 : 0
                    })
                });

                const result = await response.json();

                if (result.success) {
                    const todoText = checkbox.nextElementSibling;
                    todoText.classList.toggle('completed');
                } else {
                    checkbox.checked = !checkbox.checked;
                    alert(result.message);
                }
            } catch (error) {
                checkbox.checked = !checkbox.checked;
                alert('Não foi possível atualizar a tarefa');
            }
        }

        // Remover tarefa
        async function deleteTodo(id, element) {
            try {
                console.log(`Deletando tarefa com ID: ${id}`);
                const response = await fetch(`/todos/${id}`, {
                    method: 'DELETE'
                });

                const result = await response.json();

                if (result.success) {
                    element.remove();
                } else {
                    alert(result.message);
                }
            } catch (error) {
                alert('Não foi possível remover a tarefa');
            }
        }

        // Carregar tarefas ao iniciar
        loadTodos();
    </script>
</body>
</html>

Configurando as Rotas

Atualize o arquivo src/App.php para incluir as rotas da TodoList:

use App\Http\Controllers\TodoController;

$app = new \Lithe\App;

// Rota para a página principal
$app->get('/', [TodoController::class, 'index']);

// Rotas da API
$app->get('/todos/list', [TodoController::class, 'list']);
$app->post('/todos', [TodoController::class, 'store']);
$app->put('/todos/:id', [TodoController::class, 'update']);
$app->delete('/todos/:id', [TodoController::class, 'delete']);

$app->listen();

Executando a Aplicação

Para iniciar o servidor de desenvolvimento, execute:

php line serve

Acesse http://localhost:8000 no seu navegador para ver a aplicação em funcionamento.

Funcionalidades Implementadas

Nossa TodoList possui as seguintes funcionalidades:

Listagem de tarefas em ordem cronológica reversa
Adição de novas tarefas
Marcação de tarefas como concluídas/pendentes
Remoção de tarefas
Interface responsiva e amigável
Feedback visual para todas as ações
Tratamento de erros

Conclusão

Você agora tem uma aplicação TodoList completamente funcional construída com o Lithe. Este exemplo demonstra como criar uma aplicação web moderna com PHP, incluindo:

Estruturação adequada de código MVC
Implementação de API RESTful
Interface de usuário interativa
Integração com banco de dados
Tratamento de erros
Feedback ao usuário

A partir daqui, você pode expandir a aplicação adicionando novas funcionalidades como:

Autenticação de usuários
Categorização de tarefas
Datas de vencimento
Filtros e pesquisa

Para continuar aprendendo sobre o Lithe, acesse a Linktree, onde você pode acessar o Discord, a documentação e muito mais!

DEV Community: Lithe

Introducing Lithe SwissHelper: Simplifying PHP Development

Introducing SwissHelper

Why Use SwissHelper?

Installation

Key Features

1. Simplified String Manipulation

2. Powerful Array Handling

3. Data Validation

4. Date and Time Utilities

5. Money Formatting

6. Random String Generation

7. URL Utilities

Testing and Contributions

Want to Contribute?

Join the SwissHelper Community

Introduzindo o Lithe SwissHelper: Simplificando o Desenvolvimento em PHP

Apresentando o SwissHelper

Por que usar o SwissHelper?

Instalação

Principais Recursos

1. Manipulação de Strings Simplificada

2. Manipulação Poderosa de Arrays

3. Validação de Dados

4. Utilitários de Data e Hora

5. Formatação Monetária

6. Geração de Strings Aleatórias

7. Utilitários de URL

Testes e Contribuições

Quer Contribuir?

Junte-se à Comunidade SwissHelper

Lithe Framework: Incredible Projects Built with It!

🔹 Rialse.com

🔹 Backend for an Online Bank

🔹 Financial Management System

Why is Lithe the right choice?

Framework Lithe: Projetos incríveis feitos com ele!

🔹 Rialse.com

🔹 Backend de um Banco Online

🔹 Sistema de Gestão Financeira

Por que o Lithe é a escolha certa?

The First Project Built with Lithe Is Now Live!

Rialse.com - Online Store

Ready to Build Your Next Project with Lithe?

O Primeiro Projeto Criado com Lithe Já Está no Ar!

Rialse.com - Loja Online

Pronto para Criar Seu Próximo Projeto com o Lithe?

Lithe Events: A Lightweight and Powerful Event Handling Library for PHP

Table of Contents

Installation

Usage

Using the EventDispatcher Class

Creating an Event

Registering Listeners

Emitting Events

Removing Listeners

Using Lithe Orbis

Registering Listeners with Lithe Orbis

Emitting Events with Lithe Orbis

Removing Listeners with Lithe Orbis

Full Example

Manipulando Eventos com Simplicidade em PHP com Lithe Events

Índice

Instalação

Uso

Usando a Classe EventDispatcher

Criando um Evento

Registrando Listeners

Emitindo Eventos

Removendo Listeners

Usando Orbis

Registrando Listeners com Lithe Orbis

Emitindo Eventos com Lithe Orbis

Removendo Listeners com Lithe Orbis

Exemplo Completo

Creating a Mini Blog API with Lithe and Eloquent

Step 1: Install Lithe

Step 2: Configure the Database

Step 3: Create the Model and Migration for Posts

Post Model