Introdução

Neste tutorial, iremos abordar a criação de uma API RESTful utilizando Vala, um linguagem de programação moderna e que combina a sintaxe do C com funcionalidades de linguagens modernas, como Java e C#. Usaremos o framework GNOME GLib para gerenciar a infraestrutura do aplicativo e o Vala-ORM para facilitar a manipulação de dados através de um mapeamento objeto-relacional optimizado. O objetivo deste guia é fornecer a desenvolvedores e entusiastas as ferramentas e passos necessários para criar uma API funcional e estruturada que poderá ser utilizada em diversas aplicações. Ao longo deste tutorial, você aprenderá desde a configuração do ambiente até a implementação e testes da sua API.

Etapas

  1. Configuração do Ambiente de Desenvolvimento

    Antes de iniciarmos a codificação, certifique-se de que você possui o ambiente de desenvolvimento adequado instalado. Você precisará do Vala, do GNOME GLib e do Vala-ORM. Para isso, você pode instalar as dependências necessárias utilizando o gerenciador de pacotes da sua distribuição, como APT ou DNF. As instruções a seguir são para uma distribuição baseada em Debian.

    commands
    # Atualizar o sistema
    sudo apt update
    # Instalar Vala, GNOME GLib e Vala-ORM
    sudo apt install valac libglib2.0-dev valac-gnome valac-orm

  2. Estrutura do Projeto

    Crie uma nova pasta para o seu projeto e crie a estrutura necessária. A estrutura básica incluirá diretórios para o código-fonte e para os testes. Navegue até a pasta do seu projeto e use os comandos abaixo:

    commands
    mkdir -p MyApi/src/MyApi
    mkdir -p MyApi/tests

  3. Criando a Classe de Modelo

    Vamos criar uma classe chamada `ValidationData`, que representará os dados que serão manipulados pela API. Adicione um arquivo chamado `validation_data.vala` dentro do diretório `src/MyApi` com o seguinte conteúdo:

    validation_data.vala
    using GLib;
    
    public class MyApi.ValidationData : Object {
        public string id;
        public string validation_result;
    
        public ValidationData(string id, string validation_result) {
            this.id = id;
            this.validation_result = validation_result;
        }
    }

  4. Configurando o ORM Vala-ORM

    Agora, vamos configurar o Vala-ORM. Crie um arquivo chamado `db_connection.vala` em `src/MyApi`, que cuidará da conexão com o banco de dados e inicialização do ORM.

    db_connection.vala
    using ValaORM;
    
    public class MyApi.DatabaseConnection {
        private static Database db;
    
        public static void connect() {
            db = Database.open("sqlite:///path/to/your/database.db");
        }
    
        public static Database get_db() {
            return db;
        }
    }

  5. Implementando os Repositórios

    Agora, vamos implementar um repositório que usará o ORM para interagir com a base de dados. Adicione um arquivo chamado `validation_data_repository.vala` em `src/MyApi`.

    validation_data_repository.vala
    using ValaORM;
    
    public class MyApi.ValidationDataRepository {
        public static ValidationData find_by_id(string id) {
            var result = DatabaseConnection.get_db().query("SELECT * FROM validation_data WHERE id = ?", id);
            return result[0] as ValidationData;
        }
    
        // Implementar métodos para save, update e delete
    }

  6. Criando o Controlador da API

    Agora, precisamos de um controlador para gerenciar as requisições à API. Crie um arquivo chamado `api_controller.vala` em `src/MyApi` e implemente os handlers.

    api_controller.vala
    using GLib;
    
    public class MyApi.ApiController : Object {
        public void get_validation_data(string id) {
            var data = ValidationDataRepository.find_by_id(id);
            // Retornar JSON com os dados
        }
    
        public void post_validation_data(ValidationData data) {
            // Lógica para salvar os dados
        }
    }

  7. Configurando o Servidor HTTP

    Configure o servidor HTTP para receber as requisições. Adicione um arquivo chamado `server.vala` em `src/MyApi` para inicializar o servidor.

    server.vala
    using GLib;
    using Soup;
    
    int main(string[] args) {
        var server = new Soup.Server();
        server.add_handler("/validation_data", (server, msg, path, query) => {
            // Aqui você chamará o ApiController
        });
        server.listen_all(8080, Soup.ServerListenOptions.NONE, null);
        return 0;
    }

  8. Executando a Aplicação e Testes

    Para compilar e executar sua aplicação, use o comando valac. Certifique-se que você está no diretório raiz do projeto e execute os seguintes comandos:

    commands
    valac src/MyApi/*.vala -o my_api `pkg-config --cflags --libs glib-2.0 gio-2.0`
    ./my_api

  9. Testando a API

    Após iniciar o servidor, você pode testar os endpoints usando ferramentas como Postman ou cURL. Use os comandos cURL para fazer requisições e validar os resultados da API.

    curl_examples
    # Testar GET Validation Data
    curl -X GET http://localhost:8080/validation_data?id=1
    # Testar POST Validation Data
    curl -X POST -H "Content-Type: application/json" -d '{"id": "1", "validation_result": "valid"}' http://localhost:8080/validation_data

Conclusão

Neste tutorial, você aprendeu a desenvolver uma API RESTful utilizando Vala, GNOME GLib e Vala-ORM. Abordamos desde a configuração do ambiente até a implementação da lógica de manipulação de dados, controle de requisições e a configuração do servidor HTTP. Com isso, você tem a base necessária para expandir ou adaptar sua API para projetos futuros, além de estar mais familiarizado com o uso do Vala como uma alternativa viável para desenvolvimento de aplicações modernas.

Hashtags

#Vala #GNOME #API #RESTful #SoftwareDevelopment